Debian Codegraph @

src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/tests/httpapiex_ut/httpapiex_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 size_t currentmalloc_call = 0;
11 static size_t whenShallmalloc_fail = 0;
12
13 static size_t currentcalloc_call = 0;
14 static size_t whenShallcalloc_fail = 0;
15
16 static size_t currentrealloc_call = 0;
17 static size_t whenShallrealloc_fail = 0;
18
19 void* my_gballoc_malloc(size_t size)
20 {
21 void* result;
22 currentmalloc_call++;
23 if (whenShallmalloc_fail > 0)
24 {
25 if (currentmalloc_call == whenShallmalloc_fail)
26 {
27 result = NULL;
28 }
29 else
30 {
31 result = malloc(size);
32 }
33 }
34 else
35 {
36 result = malloc(size);
37 }
38 return result;
39 }
40
41 void* my_gballoc_calloc(size_t nmemb, size_t size)
42 {
43 void* result;
44 currentcalloc_call++;
45 if (whenShallcalloc_fail > 0)
46 {
47 if (currentcalloc_call == whenShallcalloc_fail)
48 {
49 result = NULL;
50 }
51 else
52 {
53 result = calloc(nmemb, size);
54 }
55 }
56 else
57 {
58 result = calloc(nmemb, size);
59 }
60 return result;
61 }
62
63 void* my_gballoc_realloc(void* ptr, size_t size)
64 {
65 void* result;
66 currentrealloc_call++;
67 if (whenShallrealloc_fail > 0)
68 {
69 if (currentrealloc_call == whenShallrealloc_fail)
70 {
71 result = NULL;
72 }
73 else
74 {
75 result = realloc(ptr, size);
76 }
77 }
78 else
79 {
80 result = realloc(ptr, size);
81 }
82
83 return result;
84 }
85
86 void my_gballoc_free(void* ptr)
87 {
88 free(ptr);
89 }
90
91 #include "testrunnerswitcher.h"
92 #include "azure_macro_utils/macro_utils.h"
93 #include "umock_c/umock_c.h"
94 #include "umock_c/umocktypes_charptr.h"
95
96 #define ENABLE_MOCKS
97
98 #include "azure_c_shared_utility/crt_abstractions.h"
99 #include "azure_c_shared_utility/vector.h"
100 #include "azure_c_shared_utility/map.h"
101 #include "azure_c_shared_utility/strings.h"
102 #include "azure_c_shared_utility/buffer_.h"
103 #include "azure_c_shared_utility/httpheaders.h"
104 #include "azure_c_shared_utility/httpapi.h"
105
106 static size_t currentHTTPAPI_SaveOption_call;
107 static size_t whenShallHTTPAPI_SaveOption_fail;
108
109 static size_t currentBUFFER_content_call;
110 static size_t whenShallBUFFER_content_fail;
111
112 static size_t currentBUFFER_size_call;
113 static size_t whenShallBUFFER_size_fail;
114
115 #define N_MAX_FAILS 5
116 static size_t currentHTTPAPI_CreateConnection_call;
117 static size_t whenShallHTTPAPI_CreateConnection_fail[N_MAX_FAILS];
118
119 static size_t currentHTTPAPI_Init_call;
120 static size_t whenShallHTTPAPI_Init_fail[N_MAX_FAILS];
121 static size_t HTTPAPI_Init_calls;
122
123 STRING_HANDLE my_STRING_construct(const char* psz)
124 {
125 (void)psz;
126 return (STRING_HANDLE)malloc(1);
127 }
128
129 void my_STRING_delete(STRING_HANDLE handle)
130 {
131 free(handle);
132 }
133
134 HTTP_HEADERS_HANDLE my_HTTPHeaders_Alloc(void)
135 {
136 return (HTTP_HEADERS_HANDLE)malloc(1);
137 }
138
139 void my_HTTPHeaders_Free(HTTP_HEADERS_HANDLE handle)
140 {
141 free(handle);
142 }
143
144 BUFFER_HANDLE my_BUFFER_new(void)
145 {
146 return (BUFFER_HANDLE)malloc(1);
147 }
148
149 void my_BUFFER_delete(BUFFER_HANDLE handle)
150 {
151 free(handle);
152 }
153
154 HTTPAPI_RESULT my_HTTPAPI_Init(void)
155 {
156 HTTPAPI_RESULT result2;
157 size_t i;
158 currentHTTPAPI_Init_call++;
159 for (i = 0; i < N_MAX_FAILS; i++)
160 {
161 if (whenShallHTTPAPI_Init_fail[i] > 0)
162 {
163 if (currentHTTPAPI_Init_call == whenShallHTTPAPI_Init_fail[i])
164 {
165 break;
166 }
167 }
168 }
169
170 if (i == N_MAX_FAILS)
171 {
172 HTTPAPI_Init_calls++;
173 result2 = HTTPAPI_OK;
174 }
175 else
176 {
177 result2 = HTTPAPI_ERROR;
178 }
179 return result2;
180 }
181
182 void my_HTTPAPI_Deinit(void)
183 {
184 HTTPAPI_Init_calls--;
185 }
186
187 HTTP_HANDLE my_HTTPAPI_CreateConnection(const char* hostName)
188 {
189 HTTP_HANDLE result2;
190 size_t i;
191 (void)hostName;
192 currentHTTPAPI_CreateConnection_call++;
193 for (i = 0; i < N_MAX_FAILS; i++)
194 {
195 if (whenShallHTTPAPI_CreateConnection_fail[i] > 0)
196 {
197 if (currentHTTPAPI_CreateConnection_call == whenShallHTTPAPI_CreateConnection_fail[i])
198 {
199 result2 = (HTTP_HANDLE)NULL;
200 break;
201 }
202 }
203 }
204
205 if (i == N_MAX_FAILS)
206 {
207 result2 = (HTTP_HANDLE)malloc(1);
208 }
209 else
210 {
211 result2 = NULL;
212 }
213 return result2;
214 }
215
216 void my_HTTPAPI_CloseConnection(HTTP_HANDLE handle)
217 {
218 free(handle);
219 }
220
221 HTTPAPI_RESULT my_HTTPAPI_CloneOption(const char* optionName, const void* value, const void** savedValue)
222 {
223 HTTPAPI_RESULT result2;
224 currentHTTPAPI_SaveOption_call++;
225 if (currentHTTPAPI_SaveOption_call == whenShallHTTPAPI_SaveOption_fail)
226 {
227 result2 = HTTPAPI_ERROR;
228 }
229 else
230 {
231 result2 = HTTPAPI_OK;
232 if (strcmp("someOption", optionName) == 0)
233 {
234 char* temp;
235 temp = (char *)malloc(strlen((const char*)value) + 1);
236 strcpy(temp, (const char*)value);
237 *savedValue = temp;
238 }
239 else if (strcmp("someOption1", optionName) == 0)
240 {
241 char* temp;
242 temp = (char *)malloc(strlen((const char*)value) + 1);
243 strcpy(temp, (const char*)value);
244 *savedValue = temp;
245 }
246 else if (strcmp("someOption2", optionName) == 0)
247 {
248 char* temp;
249 temp = (char *)malloc(strlen((const char*)value) + 1);
250 strcpy(temp, (const char*)value);
251 *savedValue = temp;
252 }
253 else
254 {
255 result2 = HTTPAPI_INVALID_ARG;
256 }
257 }
258 return result2;
259 }
260
261 #ifdef __cplusplus
262 extern "C"
263 {
264 #endif
265
266 VECTOR_HANDLE real_VECTOR_create(size_t elementSize);
267 VECTOR_HANDLE real_VECTOR_move(VECTOR_HANDLE handle);
268 void real_VECTOR_destroy(VECTOR_HANDLE handle);
269
270 /* insertion */
271 int real_VECTOR_push_back(VECTOR_HANDLE handle, const void* elements, size_t numElements);
272
273 /* removal */
274 void real_VECTOR_erase(VECTOR_HANDLE handle, void* elements, size_t numElements);
275 void real_VECTOR_clear(VECTOR_HANDLE handle);
276
277 /* access */
278 void* real_VECTOR_element(const VECTOR_HANDLE handle, size_t index);
279 void* real_VECTOR_front(const VECTOR_HANDLE handle);
280 void* real_VECTOR_back(const VECTOR_HANDLE handle);
281 void* real_VECTOR_find_if(const VECTOR_HANDLE handle, PREDICATE_FUNCTION pred, const void* value);
282
283 /* capacity */
284 size_t real_VECTOR_size(const VECTOR_HANDLE handle);
285
286 int real_mallocAndStrcpy_s(char** destination, const char* source);
287 int real_size_tToString(char* destination, size_t destinationSize, size_t value);
288
289 #ifdef __cplusplus
290 }
291 #endif
292
293 #include "azure_c_shared_utility/gballoc.h"
294
295 #undef ENABLE_MOCKS
296
297 #include "azure_c_shared_utility/httpapiex.h"
298
299 IMPLEMENT_UMOCK_C_ENUM_TYPE(HTTPAPI_RESULT, HTTPAPI_RESULT_VALUES);
300 TEST_DEFINE_ENUM_TYPE(HTTPAPIEX_RESULT, HTTPAPIEX_RESULT_VALUES);
301 IMPLEMENT_UMOCK_C_ENUM_TYPE(HTTPAPIEX_RESULT, HTTPAPIEX_RESULT_VALUES);
302 IMPLEMENT_UMOCK_C_ENUM_TYPE(HTTP_HEADERS_RESULT, HTTP_HEADERS_RESULT_VALUES);
303 IMPLEMENT_UMOCK_C_ENUM_TYPE(HTTPAPI_REQUEST_TYPE, HTTPAPI_REQUEST_TYPE_VALUES);
304
305 #define TEST_HOSTNAME "aaa"
306 #define TEST_RELATIVE_PATH "nothing/to/see/here/devices"
307 #define TEST_REQUEST_HTTP_HEADERS (HTTP_HEADERS_HANDLE) 0x42
308 #define TEST_REQUEST_BODY (BUFFER_HANDLE) 0x43
309 #define TEST_RESPONSE_HTTP_HEADERS (HTTP_HEADERS_HANDLE) 0x45
310 #define TEST_RESPONSE_BODY (BUFFER_HANDLE) 0x46
311 #define TEST_HTTP_HEADERS_HANDLE (HTTP_HEADERS_HANDLE) 0x47
312 #define TEST_BUFFER_REQ_BODY (BUFFER_HANDLE) 0x48
313 #define TEST_BUFFER_RESP_BODY (BUFFER_HANDLE) 0x49
314 unsigned char* TEST_BUFFER = (unsigned char*)"333333";
315 #define TEST_BUFFER_SIZE 6
316
317 static TEST_MUTEX_HANDLE g_testByTest;
318
319 static void createHttpObjects(HTTP_HEADERS_HANDLE* requestHttpHeaders, HTTP_HEADERS_HANDLE* responseHttpHeaders)
320 {
321 /*assumed to never fail*/
322 *requestHttpHeaders = HTTPHeaders_Alloc();
323 *responseHttpHeaders = HTTPHeaders_Alloc();
324 if (
325 (*requestHttpHeaders == NULL) ||
326 (*responseHttpHeaders == NULL)
327 )
328 {
329 ASSERT_FAIL("unable to build test prerequisites");
330 }
331 }
332
333 static void destroyHttpObjects(HTTP_HEADERS_HANDLE* requestHttpHeaders, HTTP_HEADERS_HANDLE* responseHttpHeaders)
334 {
335 HTTPHeaders_Free(*requestHttpHeaders);
336 *requestHttpHeaders = NULL;
337 HTTPHeaders_Free(*responseHttpHeaders);
338 *responseHttpHeaders = NULL;
339 }
340
341 /*this function takes care of setting expected call for httpapiex_executerequest assuming all the parameters are non-null*/
342 static void setupAllCallBeforeHTTPsequence(void)
343 {
344 /*this is building the host and content-length for the http request headers*/
345 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
346 .IgnoreArgument(1).SetReturn(TEST_BUFFER_SIZE);
347 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, TEST_BUFFER_SIZE))
348 .IgnoreArgument(1).IgnoreArgument(2);
349 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
350 .IgnoreArgument(1);
351 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
352 .IgnoreArgument(1);
353 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Content-Length", MU_TOSTRING(TEST_BUFFER_SIZE)))
354 .IgnoreArgument(1);
355 }
356
357 static void setupAllCallForHTTPsequence(const char* relativePath, HTTP_HEADERS_HANDLE requestHttpHeaders, BUFFER_HANDLE requestHttpBody, HTTP_HEADERS_HANDLE responseHttpHeaders, BUFFER_HANDLE responseHttpBody)
358 {
359 size_t requestHttpBodyLength = TEST_BUFFER_SIZE;
360 const unsigned char* requestHttpBodyContent = TEST_BUFFER;
361 STRICT_EXPECTED_CALL(HTTPAPI_Init());
362
363 /*this is getting the hostname for the HTTAPI_connect call)*/
364 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
365 .IgnoreArgument(1);
366 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
367 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
368 .IgnoreArgument(1);
369
370 STRICT_EXPECTED_CALL(BUFFER_length(requestHttpBody))
371 .SetReturn(TEST_BUFFER_SIZE);
372
373 STRICT_EXPECTED_CALL(BUFFER_u_char(requestHttpBody))
374 .SetReturn(TEST_BUFFER);
375
376 /*this is getting the buffer content and buffer length to pass to httpapi_executerequest*/
377 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
378 IGNORED_PTR_ARG,
379 HTTPAPI_REQUEST_HEAD,
380 relativePath,
381 requestHttpHeaders,
382 requestHttpBodyContent,
383 requestHttpBodyLength,
384 IGNORED_PTR_ARG,
385 responseHttpHeaders,
386 responseHttpBody))
387 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
388 .IgnoreArgument(1)
389 .IgnoreArgument(7)
390 ;
391 }
392
393 /*every time HttpApi_Execute request is executed several things will be auto-aupdated by the code*/
394 /*request headers to match the content-length, host to match hostname*/
395 static void prepareHTTPAPIEX_ExecuteRequest(unsigned int *asGivenByHttpApi, HTTP_HEADERS_HANDLE requestHttpHeaders, HTTP_HEADERS_HANDLE responseHttpHeaders, BUFFER_HANDLE responseHttpBody, HTTPAPI_RESULT resultToBeUsed)
396 {
397 /*this is building the host and content-length for the http request headers, this happens every time*/
398 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
399 .IgnoreArgument(1).SetReturn(TEST_BUFFER_SIZE);
400 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, TEST_BUFFER_SIZE))
401 .IgnoreArgument(1).IgnoreArgument(2);
402 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
403 .IgnoreArgument(1);
404 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
405 .IgnoreArgument(1);
406 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Content-Length", MU_TOSTRING(TEST_BUFFER_SIZE)))
407 .IgnoreArgument(1);
408
409 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
410 .IgnoreArgument(1).SetReturn(TEST_BUFFER_SIZE);
411 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
412 .IgnoreArgument(1).SetReturn(TEST_BUFFER);
413 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
414 IGNORED_PTR_ARG,
415 HTTPAPI_REQUEST_HEAD,
416 TEST_RELATIVE_PATH,
417 requestHttpHeaders,
418 IGNORED_PTR_ARG,
419 TEST_BUFFER_SIZE,
420 IGNORED_PTR_ARG,
421 responseHttpHeaders,
422 responseHttpBody))
423 .IgnoreArgument(1)
424 .IgnoreArgument(4)
425 .IgnoreArgument(5)
426 .IgnoreArgument(7)
427 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
428 .CopyOutArgumentBuffer(7, asGivenByHttpApi, sizeof(*asGivenByHttpApi))
429 .SetReturn(resultToBeUsed);
430 }
431
432 MU_DEFINE_ENUM_STRINGS(UMOCK_C_ERROR_CODE, UMOCK_C_ERROR_CODE_VALUES)
433
434 static void on_umock_c_error(UMOCK_C_ERROR_CODE error_code)
435 {
436 ASSERT_FAIL("umock_c reported error :%" PRI_MU_ENUM "", MU_ENUM_VALUE(UMOCK_C_ERROR_CODE, error_code));
437 }
438
439 BEGIN_TEST_SUITE(httpapiex_unittests)
440
441 TEST_SUITE_INITIALIZE(TestClassInitialize)
442 {
443 int result;
444
445 g_testByTest = TEST_MUTEX_CREATE();
446 ASSERT_IS_NOT_NULL(g_testByTest);
447
448 umock_c_init(on_umock_c_error);
449
450 result = umocktypes_charptr_register_types();
451 ASSERT_ARE_EQUAL(int, 0, result);
452
453 REGISTER_TYPE(HTTPAPI_RESULT, HTTPAPI_RESULT);
454 REGISTER_TYPE(HTTPAPIEX_RESULT, HTTPAPIEX_RESULT);
455 REGISTER_TYPE(HTTP_HEADERS_RESULT, HTTP_HEADERS_RESULT);
456 REGISTER_TYPE(HTTPAPI_REQUEST_TYPE, HTTPAPI_REQUEST_TYPE);
457 REGISTER_UMOCK_ALIAS_TYPE(VECTOR_HANDLE, void*);
458 REGISTER_UMOCK_ALIAS_TYPE(const VECTOR_HANDLE, void*);
459 REGISTER_UMOCK_ALIAS_TYPE(PREDICATE_FUNCTION, void*);
460 REGISTER_UMOCK_ALIAS_TYPE(BUFFER_HANDLE, void*);
461 REGISTER_UMOCK_ALIAS_TYPE(STRING_HANDLE, void*);
462 REGISTER_UMOCK_ALIAS_TYPE(HTTP_HEADERS_HANDLE, void*);
463 REGISTER_UMOCK_ALIAS_TYPE(HTTP_HANDLE, void*);
464 REGISTER_UMOCK_ALIAS_TYPE(const unsigned char*, void*);
465 REGISTER_GLOBAL_MOCK_HOOK(gballoc_malloc, my_gballoc_malloc);
466 REGISTER_GLOBAL_MOCK_HOOK(gballoc_calloc, my_gballoc_calloc);
467 REGISTER_GLOBAL_MOCK_HOOK(gballoc_realloc, my_gballoc_realloc);
468 REGISTER_GLOBAL_MOCK_HOOK(gballoc_free, my_gballoc_free);
469 REGISTER_GLOBAL_MOCK_HOOK(STRING_construct, my_STRING_construct);
470 REGISTER_GLOBAL_MOCK_HOOK(STRING_delete, my_STRING_delete);
471 REGISTER_GLOBAL_MOCK_RETURN(STRING_c_str, TEST_HOSTNAME);
472 REGISTER_GLOBAL_MOCK_HOOK(HTTPHeaders_Alloc, my_HTTPHeaders_Alloc);
473 REGISTER_GLOBAL_MOCK_HOOK(HTTPHeaders_Free, my_HTTPHeaders_Free);
474 REGISTER_GLOBAL_MOCK_RETURN(HTTPHeaders_AddHeaderNameValuePair, HTTP_HEADERS_OK);
475 REGISTER_GLOBAL_MOCK_RETURN(HTTPHeaders_ReplaceHeaderNameValuePair, HTTP_HEADERS_OK);
476 REGISTER_GLOBAL_MOCK_HOOK(BUFFER_new, my_BUFFER_new);
477 REGISTER_GLOBAL_MOCK_HOOK(BUFFER_delete, my_BUFFER_delete);
478 REGISTER_GLOBAL_MOCK_RETURN(BUFFER_u_char, TEST_BUFFER);
479 REGISTER_GLOBAL_MOCK_RETURN(BUFFER_length, TEST_BUFFER_SIZE);
480 REGISTER_GLOBAL_MOCK_HOOK(HTTPAPI_Init, my_HTTPAPI_Init);
481 REGISTER_GLOBAL_MOCK_HOOK(HTTPAPI_Deinit, my_HTTPAPI_Deinit);
482 REGISTER_GLOBAL_MOCK_HOOK(HTTPAPI_CreateConnection, my_HTTPAPI_CreateConnection);
483 REGISTER_GLOBAL_MOCK_HOOK(HTTPAPI_CloseConnection, my_HTTPAPI_CloseConnection);
484 REGISTER_GLOBAL_MOCK_RETURN(HTTPAPI_ExecuteRequest, HTTPAPI_OK);
485 REGISTER_GLOBAL_MOCK_RETURN(HTTPAPI_SetOption, HTTPAPI_OK);
486 REGISTER_GLOBAL_MOCK_HOOK(HTTPAPI_CloneOption, my_HTTPAPI_CloneOption);
487 REGISTER_GLOBAL_MOCK_HOOK(VECTOR_create, real_VECTOR_create);
488 REGISTER_GLOBAL_MOCK_HOOK(VECTOR_move, real_VECTOR_move);
489 REGISTER_GLOBAL_MOCK_HOOK(VECTOR_destroy, real_VECTOR_destroy);
490 REGISTER_GLOBAL_MOCK_HOOK(VECTOR_push_back, real_VECTOR_push_back);
491 REGISTER_GLOBAL_MOCK_HOOK(VECTOR_erase, real_VECTOR_erase);
492 REGISTER_GLOBAL_MOCK_HOOK(VECTOR_clear, real_VECTOR_clear);
493 REGISTER_GLOBAL_MOCK_HOOK(VECTOR_element, real_VECTOR_element);
494 REGISTER_GLOBAL_MOCK_HOOK(VECTOR_front, real_VECTOR_front);
495 REGISTER_GLOBAL_MOCK_HOOK(VECTOR_back, real_VECTOR_back);
496 REGISTER_GLOBAL_MOCK_HOOK(VECTOR_find_if, real_VECTOR_find_if);
497 REGISTER_GLOBAL_MOCK_HOOK(VECTOR_size, real_VECTOR_size);
498 REGISTER_GLOBAL_MOCK_HOOK(mallocAndStrcpy_s, real_mallocAndStrcpy_s);
499 REGISTER_GLOBAL_MOCK_HOOK(size_tToString, real_size_tToString);
500 }
501
502 TEST_SUITE_CLEANUP(TestClassCleanup)
503 {
504 umock_c_deinit();
505
506 TEST_MUTEX_DESTROY(g_testByTest);
507 }
508
509 TEST_FUNCTION_INITIALIZE(TestMethodInitialize)
510 {
511 size_t i;
512
513 if (TEST_MUTEX_ACQUIRE(g_testByTest))
514 {
515 ASSERT_FAIL("our mutex is ABANDONED. Failure in test framework");
516 }
517
518 currentmalloc_call = 0;
519 whenShallmalloc_fail = 0;
520
521 currentcalloc_call = 0;
522 whenShallcalloc_fail = 0;
523
524 currentrealloc_call = 0;
525 whenShallrealloc_fail = 0;
526
527 currentHTTPAPI_SaveOption_call = 0;
528 whenShallHTTPAPI_SaveOption_fail = 0;
529
530 currentBUFFER_content_call = 0;
531 whenShallBUFFER_content_fail = 0;
532
533 currentBUFFER_size_call = 0;
534 whenShallBUFFER_size_fail = 0;
535
536 HTTPAPI_Init_calls = 0;
537
538 currentHTTPAPI_CreateConnection_call = 0;
539 for(i=0;i<N_MAX_FAILS;i++) whenShallHTTPAPI_CreateConnection_fail[i] = 0;
540
541 currentHTTPAPI_Init_call = 0;
542 for (i = 0; i<N_MAX_FAILS; i++) whenShallHTTPAPI_Init_fail[i] = 0;
543
544 umock_c_reset_all_calls();
545 }
546
547 TEST_FUNCTION_CLEANUP(TestMethodCleanup)
548 {
549 TEST_MUTEX_RELEASE(g_testByTest);
550 }
551
552 /*Tests_SRS_HTTPAPIEX_21_044: [HTTPAPIEX_Init shall initialize the HTTP by calling HTTAPI_Init.] */
553 TEST_FUNCTION(HTTPAPIEX_Init_initialize_HTTP_succeeds)
554 {
555 /// arrange
556 STRICT_EXPECTED_CALL(HTTPAPI_Init()).SetReturn(HTTPAPI_OK);
557
558 /// act
559 HTTPAPIEX_RESULT result = HTTPAPIEX_Init();
560
561 /// assert
562 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
563 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
564
565 ///destroy
566 HTTPAPIEX_Deinit();
567 }
568
569 /*Tests_SRS_HTTPAPIEX_21_045: [If HTTPAPIEX_Init is calling more than once, it shall initialize the HTTP by calling HTTAPI_Init only once, and return success for all calls.] */
570 TEST_FUNCTION(HTTPAPIEX_Init_multiple_calls_initialize_HTTP_only_once_succeeds)
571 {
572 /// arrange
573 STRICT_EXPECTED_CALL(HTTPAPI_Init()).SetReturn(HTTPAPI_OK);
574
575 /// act
576 HTTPAPIEX_RESULT result = HTTPAPIEX_Init();
577 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
578 result = HTTPAPIEX_Init();
579 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
580 result = HTTPAPIEX_Init();
581
582 /// assert
583 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
584 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
585
586 ///destroy
587 HTTPAPIEX_Deinit();
588 HTTPAPIEX_Deinit();
589 HTTPAPIEX_Deinit();
590 }
591
592 /*Tests_SRS_HTTPAPIEX_21_046: [If HTTAPI_Init, HTTPAPIEX_Init shall return HTTPAPIEX_ERROR.] */
593 TEST_FUNCTION(HTTPAPIEX_Init_initialize_HTTP_fails)
594 {
595 /// arrange
596 STRICT_EXPECTED_CALL(HTTPAPI_Init()).SetReturn(HTTPAPI_ERROR);
597
598 /// act
599 HTTPAPIEX_RESULT result = HTTPAPIEX_Init();
600
601 /// assert
602 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_ERROR, result);
603 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
604 }
605
606 /*Tests_SRS_HTTPAPIEX_21_047: [HTTPAPIEX_Deinit shall de-initialize the HTTP by calling HTTAPI_Deinit.] */
607 TEST_FUNCTION(HTTPAPIEX_Deinit_deinitialize_HTTP_succeeds)
608 {
609 /// arrange
610 STRICT_EXPECTED_CALL(HTTPAPI_Init()).SetReturn(HTTPAPI_OK);
611 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, HTTPAPIEX_Init());
612
613 umock_c_reset_all_calls();
614 STRICT_EXPECTED_CALL(HTTPAPI_Deinit());
615
616 /// act
617 HTTPAPIEX_Deinit();
618
619 /// assert
620 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
621
622 ///destroy
623 }
624
625 /*Tests_SRS_HTTPAPIEX_02_001: [If parameter hostName is NULL then HTTPAPIEX_Create shall return NULL.] */
626 TEST_FUNCTION(HTTPAPIEX_Create_with_NULL_name_fails)
627 {
628 /// arrange
629
630 /// act
631 HTTPAPIEX_HANDLE result = HTTPAPIEX_Create(NULL);
632
633 /// assert
634 ASSERT_ARE_EQUAL(void_ptr, NULL, result);
635 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
636 }
637
638 /*Tests_SRS_HTTPAPIEX_02_002: [Parameter hostName shall be saved.] */
639 /*Tests_SRS_HTTPAPIEX_02_004: [Otherwise, HTTPAPIEX_Create shall return a HTTAPIEX_HANDLE suitable for further calls to the module.]*/
640 TEST_FUNCTION(HTTPAPIEX_Create_succeeds)
641 {
642 /// arrange
643 HTTPAPIEX_HANDLE result;
644 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
645 .IgnoreAllArguments();
646 STRICT_EXPECTED_CALL(STRING_construct(TEST_HOSTNAME));
647
648 STRICT_EXPECTED_CALL(VECTOR_create(IGNORED_NUM_ARG))
649 .IgnoreArgument(1);
650
651 /// act
652 result = HTTPAPIEX_Create(TEST_HOSTNAME);
653
654 /// assert
655 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, result);
656 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
657
658 ///destroy
659 HTTPAPIEX_Destroy(result);
660 }
661
662 /*Tests_SRS_HTTPAPIEX_02_042: [HTTPAPIEX_Destroy shall free all the resources used by HTTAPIEX_HANDLE.] */
663 TEST_FUNCTION(HTTPAPIEX_Destroy_frees_resources_1) /*this is destroy after created*/
664 {
665 /// arrange
666 HTTPAPIEX_HANDLE handle = HTTPAPIEX_Create(TEST_HOSTNAME);
667 umock_c_reset_all_calls();
668
669 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*this is the copy of the hostName*/
670 .IgnoreArgument(1);
671
672 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
673 .IgnoreArgument(1);
674
675 STRICT_EXPECTED_CALL(VECTOR_destroy(IGNORED_PTR_ARG)) /*these are the options vector*/
676 .IgnoreArgument(1);
677
678 STRICT_EXPECTED_CALL(gballoc_free(handle)); /*this is handle data*/
679
680 /// act
681 HTTPAPIEX_Destroy(handle);
682
683 /// assert
684 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
685 }
686
687 /*Tests_SRS_HTTPAPIEX_02_042: [HTTPAPIEX_Destroy shall free all the resources used by HTTAPIEX_HANDLE.] */
688 TEST_FUNCTION(HTTPAPIEX_Destroy_frees_resources_2) /*this is destroy after setting options*/
689 {
690 /// arrange
691 HTTPAPIEX_HANDLE handle = HTTPAPIEX_Create(TEST_HOSTNAME);
692 (void)HTTPAPIEX_SetOption(handle, "notAnOption", "notAValue"); /*this is not something handled*/
693 (void)HTTPAPIEX_SetOption(handle, "someOption1", "someValue"); /*this is something handled*/
694 umock_c_reset_all_calls();
695
696 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*this is the copy of the hostName*/
697 .IgnoreArgument(1);
698
699 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
700 .IgnoreArgument(1);
701
702 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 0))
703 .IgnoreArgument(1);
704
705 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*this is "someValue"*/
706 .IgnoreArgument(1);
707 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*this is "someOption"*/
708 .IgnoreArgument(1);
709
710 STRICT_EXPECTED_CALL(VECTOR_destroy(IGNORED_PTR_ARG)) /*these are the options vector*/
711 .IgnoreArgument(1);
712
713 STRICT_EXPECTED_CALL(gballoc_free(handle)); /*this is handle data*/
714
715 /// act
716 HTTPAPIEX_Destroy(handle);
717
718 /// assert
719 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
720 }
721
722 /*Tests_SRS_HTTPAPIEX_02_042: [HTTPAPIEX_Destroy shall free all the resources used by HTTAPIEX_HANDLE.] */
723 TEST_FUNCTION(HTTPAPIEX_Destroy_frees_resources_3) /*this is destroy after having a sequence build*/
724 {
725 /// arrange
726 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
727
728 unsigned int httpStatusCode;
729 HTTP_HEADERS_HANDLE requestHttpHeaders;
730 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
731 HTTP_HEADERS_HANDLE responseHttpHeaders;
732 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
733 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
734 setupAllCallBeforeHTTPsequence();
735 setupAllCallForHTTPsequence(TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, responseHttpHeaders, responseHttpBody);
736 (void)HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
737 umock_c_reset_all_calls();
738
739 STRICT_EXPECTED_CALL(HTTPAPI_CloseConnection(IGNORED_PTR_ARG)) /*closing the conenction*/
740 .IgnoreArgument(1);
741 STRICT_EXPECTED_CALL(HTTPAPI_Deinit()); /*deinit */
742
743 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*this is hostname*/
744 .IgnoreArgument(1);
745
746 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
747 .IgnoreArgument(1);
748
749 STRICT_EXPECTED_CALL(VECTOR_destroy(IGNORED_PTR_ARG)) /*these are the options vector*/
750 .IgnoreArgument(1);
751
752 STRICT_EXPECTED_CALL(gballoc_free(httpapiexhandle)); /*this is the handle*/
753
754 /// act
755 HTTPAPIEX_Destroy(httpapiexhandle);
756
757 ///assert
758
759 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
760
761 ///destroy
762 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
763
764 }
765
766 /*Tests_SRS_HTTPAPIEX_21_050: [If HTTPAPIEX_Init was called, HTTPAPI_Destroy shall not call HTTPAPI_Deinit.] */
767 TEST_FUNCTION(HTTPAPIEX_Destroy_not_call_HTTPAPI_Deinit_after_HTTPAPIEX_Init_succeeds)
768 {
769 /// arrange
770 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, HTTPAPIEX_Init());
771 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
772
773 unsigned int httpStatusCode;
774 HTTP_HEADERS_HANDLE requestHttpHeaders;
775 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
776 HTTP_HEADERS_HANDLE responseHttpHeaders;
777 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
778 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
779 setupAllCallBeforeHTTPsequence();
780 setupAllCallForHTTPsequence(TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, responseHttpHeaders, responseHttpBody);
781 (void)HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
782 umock_c_reset_all_calls();
783
784 STRICT_EXPECTED_CALL(HTTPAPI_CloseConnection(IGNORED_PTR_ARG)) /*closing the conenction*/
785 .IgnoreArgument(1);
786
787 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) /*this is hostname*/
788 .IgnoreArgument(1);
789
790 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG))
791 .IgnoreArgument(1);
792
793 STRICT_EXPECTED_CALL(VECTOR_destroy(IGNORED_PTR_ARG)) /*these are the options vector*/
794 .IgnoreArgument(1);
795
796 STRICT_EXPECTED_CALL(gballoc_free(httpapiexhandle)); /*this is the handle*/
797
798 /// act
799 HTTPAPIEX_Destroy(httpapiexhandle);
800
801 ///assert
802
803 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
804
805 ///destroy
806 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
807 HTTPAPIEX_Deinit();
808 }
809
810 /*Tests_SRS_HTTPAPIEX_02_005: [If creating the handle fails for any reason, then HTTAPIEX_Create shall return NULL.] */
811 TEST_FUNCTION(HTTPAPIEX_Create_fails_when_malloc_fails)
812 {
813 /// arrange
814 HTTPAPIEX_HANDLE result;
815 whenShallcalloc_fail = currentcalloc_call + 1;
816 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
817 .IgnoreAllArguments();
818
819 /// act
820 result = HTTPAPIEX_Create(TEST_HOSTNAME);
821
822 /// assert
823 ASSERT_ARE_EQUAL(void_ptr, NULL, result);
824 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
825
826 ///destroy
827 }
828
829 /*Tests_SRS_HTTPAPIEX_02_003: [If saving the parameter hostName fails for any reason, then HTTPAPIEX_Create shall return NULL.] */
830 TEST_FUNCTION(HTTPAPIEX_Create_fails_when_STRING_construct_fails)
831 {
832 /// arrange
833 HTTPAPIEX_HANDLE result;
834 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
835 .IgnoreAllArguments();
836
837 STRICT_EXPECTED_CALL(STRING_construct(TEST_HOSTNAME))
838 .SetReturn(NULL);
839
840 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
841 .IgnoreArgument(1);
842
843 /// act
844 result = HTTPAPIEX_Create(TEST_HOSTNAME);
845
846 /// assert
847 ASSERT_ARE_EQUAL(void_ptr, NULL, result);
848 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
849
850 ///destroy
851 }
852
853 /*Tests_SRS_HTTPAPIEX_02_005: [If creating the handle fails for any reason, then HTTAPIEX_Create shall return NULL.] */
854 TEST_FUNCTION(HTTPAPIEX_Create_fails_when_VECTOR_create_fails)
855 {
856 /// arrange
857 HTTPAPIEX_HANDLE result;
858 STRICT_EXPECTED_CALL(gballoc_calloc(IGNORED_NUM_ARG, IGNORED_NUM_ARG))
859 .IgnoreAllArguments();
860
861 STRICT_EXPECTED_CALL(STRING_construct(TEST_HOSTNAME));
862
863 STRICT_EXPECTED_CALL(VECTOR_create(IGNORED_NUM_ARG))
864 .IgnoreArgument(1).SetReturn(NULL);
865
866 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG))
867 .IgnoreArgument(1);
868 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
869 .IgnoreArgument(1);
870
871 /// act
872 result = HTTPAPIEX_Create(TEST_HOSTNAME);
873
874 /// assert
875 ASSERT_ARE_EQUAL(void_ptr, NULL, result);
876 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
877
878 ///destroy
879 }
880
881 /*Tests_SRS_HTTPAPIEX_02_006: [If parameter handle is NULL then HTTPAPIEX_ExecuteRequest shall fail and return HTTPAPIEX_INVALID_ARG.]*/
882 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_NULL_handle_fails)
883 {
884 ///arrange
885 unsigned int httpStatusCode;
886
887 ///act
888 HTTPAPIEX_RESULT result = HTTPAPIEX_ExecuteRequest(NULL, HTTPAPI_REQUEST_POST, TEST_RELATIVE_PATH, TEST_REQUEST_HTTP_HEADERS, TEST_REQUEST_BODY, &httpStatusCode, TEST_RESPONSE_HTTP_HEADERS, TEST_RESPONSE_BODY);
889
890 ///assert
891 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_INVALID_ARG, result);
892 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
893 }
894
895 /*Tests_SRS_HTTPAPIEX_02_007: [If parameter requestType does not indicate a valid request, HTTPAPIEX_ExecuteRequest shall fail and return HTTPAPIEX_INVALID_ARG.] */
896 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_fails_with_invalid_request_type)
897 {
898 /// arrange
899 unsigned int httpStatusCode;
900 HTTPAPIEX_RESULT result;
901
902 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
903 umock_c_reset_all_calls();
904
905 /// act
906 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, (HTTPAPI_REQUEST_TYPE)(MU_COUNT_ARG(HTTPAPI_REQUEST_TYPE_VALUES) + 1), TEST_RELATIVE_PATH, TEST_REQUEST_HTTP_HEADERS, TEST_REQUEST_BODY, &httpStatusCode, TEST_RESPONSE_HTTP_HEADERS, TEST_RESPONSE_BODY);
907
908 ///assert
909 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_INVALID_ARG, result);
910 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
911
912 ///destroy
913 HTTPAPIEX_Destroy(httpapiexhandle);
914 }
915
916 /*Tests_SRS_HTTPAPIEX_02_007: [If parameter requestType does not indicate a valid request, HTTPAPIEX_ExecuteRequest shall fail and return HTTPAPIEX_INVALID_ARG.] */
917 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_fails_with_invalid_request_type_2)
918 {
919 /// arrange
920 unsigned int httpStatusCode;
921 HTTPAPIEX_RESULT result;
922
923 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
924 umock_c_reset_all_calls();
925
926 /// act
927 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_TYPE_INVALID, TEST_RELATIVE_PATH, TEST_REQUEST_HTTP_HEADERS, TEST_REQUEST_BODY, &httpStatusCode, TEST_RESPONSE_HTTP_HEADERS, TEST_RESPONSE_BODY);
928
929 ///assert
930 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_INVALID_ARG, result);
931 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
932
933 ///destroy
934 HTTPAPIEX_Destroy(httpapiexhandle);
935 }
936
937 /*Tests_SRS_HTTPAPIEX_02_023: [HTTPAPIEX_ExecuteRequest shall try to execute the HTTP call by ensuring the following API call sequence is respected:]*/
938 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_happy_path_with_all_non_NULL_parameters)
939 {
940 /// arrange
941 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
942 HTTPAPIEX_RESULT result;
943
944 unsigned int httpStatusCode;
945 HTTP_HEADERS_HANDLE requestHttpHeaders;
946 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
947 HTTP_HEADERS_HANDLE responseHttpHeaders;
948 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
949 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
950 umock_c_reset_all_calls();
951
952 setupAllCallBeforeHTTPsequence();
953 setupAllCallForHTTPsequence(TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, responseHttpHeaders, responseHttpBody);
954
955 /// act
956 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
957
958 ///assert
959 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
960 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
961
962 ///destroy
963 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
964 HTTPAPIEX_Destroy(httpapiexhandle);
965 }
966
967 /*Tests_SRS_HTTPAPIEX_02_008: [If parameter relativePath is NULL then HTTPAPIEX_INVALID_ARG shall not assume a relative path - that is, it will assume an empty path ("").] */
968 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_NULL_relativePath_uses_empty)
969 {
970 /// arrange
971 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
972 HTTPAPIEX_RESULT result;
973
974 unsigned int httpStatusCode;
975 HTTP_HEADERS_HANDLE requestHttpHeaders;
976 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
977 HTTP_HEADERS_HANDLE responseHttpHeaders;
978 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
979 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
980 umock_c_reset_all_calls();
981
982 setupAllCallBeforeHTTPsequence();
983 setupAllCallForHTTPsequence("", requestHttpHeaders, requestHttpBody, responseHttpHeaders, responseHttpBody);
984
985 /// act
986 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, NULL, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
987
988 ///assert
989 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
990 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
991
992 ///destroy
993 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
994 HTTPAPIEX_Destroy(httpapiexhandle);
995 }
996
997 /*Tests_SRS_HTTPAPIEX_02_009: [If parameter requestHttpHeadersHandle is NULL then HTTPAPIEX_ExecuteRequest shall allocate a temporary internal instance of HTTPHEADERS, shall add to that instance the following headers
998 Host:{hostname} - as it was indicated by the call to HTTPAPIEX_Create API call
999 Content-Length:the size of the requestContent parameter, and use this instance to all the subsequent calls to HTTPAPI_ExecuteRequest as parameter httpHeadersHandle.]
1000 */
1001 /*Tests_SRS_HTTPAPIEX_02_013: [If requestContent is NULL then HTTPAPIEX_ExecuteRequest shall behave as if a buffer of zero size would have been used, that is, it shall call HTTPAPI_ExecuteRequest with parameter content = NULL and contentLength = 0.]*/
1002 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_NULL_request_headers_and_NULL_requestBody_succeeds)
1003 {
1004 /// arrange
1005 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
1006 HTTPAPIEX_RESULT result;
1007
1008 unsigned int httpStatusCode;
1009 HTTP_HEADERS_HANDLE requestHttpHeaders;
1010 HTTP_HEADERS_HANDLE responseHttpHeaders;
1011 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
1012 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1013 umock_c_reset_all_calls();
1014
1015 STRICT_EXPECTED_CALL(BUFFER_new()); /*because it makes a fake buffer*/
1016
1017 STRICT_EXPECTED_CALL(HTTPHeaders_Alloc()); /*because it makes fakes request headers*/
1018 /*this is building the host and content-length for the http request headers*/
1019 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1020 .IgnoreArgument(1).SetReturn(0);
1021 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, 0))
1022 .IgnoreArgument(1).IgnoreArgument(2);
1023 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1024 .IgnoreArgument(1);
1025 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
1026 .IgnoreArgument(1);
1027 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Content-Length", "0"))
1028 .IgnoreArgument(1);
1029
1030 /*this is getting the buffer content and buffer length to pass to httpapi_executerequest*/
1031 STRICT_EXPECTED_CALL(HTTPAPI_Init());
1032 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1033 .IgnoreArgument(1);
1034 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
1035 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
1036 .IgnoreArgument(1);
1037
1038 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1039 .IgnoreArgument(1).SetReturn(0);
1040 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
1041 .IgnoreArgument(1).SetReturn(NULL);
1042
1043 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
1044 IGNORED_PTR_ARG,
1045 HTTPAPI_REQUEST_HEAD,
1046 TEST_RELATIVE_PATH,
1047 IGNORED_PTR_ARG,
1048 IGNORED_PTR_ARG,
1049 0,
1050 IGNORED_PTR_ARG,
1051 responseHttpHeaders,
1052 responseHttpBody))
1053 .IgnoreArgument(1)
1054 .IgnoreArgument(4)
1055 .IgnoreArgument(5)
1056 .IgnoreArgument(7)
1057 ;
1058
1059 STRICT_EXPECTED_CALL(BUFFER_delete(IGNORED_PTR_ARG))
1060 .IgnoreArgument(1);
1061 STRICT_EXPECTED_CALL(HTTPHeaders_Free(IGNORED_PTR_ARG))
1062 .IgnoreArgument(1);
1063
1064 /// act
1065 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, NULL, NULL, &httpStatusCode, responseHttpHeaders, responseHttpBody);
1066
1067 ///assert
1068 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
1069 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1070
1071 ///destroy
1072 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1073 HTTPAPIEX_Destroy(httpapiexhandle);
1074 }
1075
1076 /*Tests_SRS_HTTPAPIEX_02_010: [If any of the operations in SRS_HTTAPIEX_02_009 fails, then HTTPAPIEX_ExecuteRequest shall return HTTPAPIEX_ERROR.]*/
1077 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_NULL_request_headers_and_NULL_requestBody_fails_when_HTTPHeaders_ReplaceHeaderNameValuePair_fails)
1078 {
1079 /// arrange
1080 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
1081 HTTPAPIEX_RESULT result;
1082
1083 unsigned int httpStatusCode;
1084 HTTP_HEADERS_HANDLE requestHttpHeaders;
1085 HTTP_HEADERS_HANDLE responseHttpHeaders;
1086 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
1087 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1088 umock_c_reset_all_calls();
1089
1090 STRICT_EXPECTED_CALL(BUFFER_new()); /*because it makes a fake buffer*/
1091
1092 STRICT_EXPECTED_CALL(HTTPHeaders_Alloc()); /*because it makes fakes request headers*/
1093 /*this is building the host and content-length for the http request headers*/
1094 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1095 .IgnoreArgument(1).SetReturn(0);
1096 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, 0))
1097 .IgnoreArgument(1).IgnoreArgument(2);
1098 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1099 .IgnoreArgument(1);
1100 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
1101 .IgnoreArgument(1);
1102 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Content-Length", "0"))
1103 .IgnoreArgument(1)
1104 .SetReturn(HTTP_HEADERS_ERROR);
1105
1106 STRICT_EXPECTED_CALL(HTTPHeaders_Free(IGNORED_PTR_ARG))
1107 .IgnoreArgument(1);
1108 STRICT_EXPECTED_CALL(BUFFER_delete(IGNORED_PTR_ARG))
1109 .IgnoreArgument(1);
1110
1111 /// act
1112 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, NULL, NULL, &httpStatusCode, responseHttpHeaders, responseHttpBody);
1113
1114 ///assert
1115 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_ERROR, result);
1116 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1117
1118 ///destroy
1119 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1120 HTTPAPIEX_Destroy(httpapiexhandle);
1121 }
1122
1123 /*Tests_SRS_HTTPAPIEX_02_010: [If any of the operations in SRS_HTTAPIEX_02_009 fails, then HTTPAPIEX_ExecuteRequest shall return HTTPAPIEX_ERROR.]*/
1124 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_NULL_request_headers_and_NULL_requestBody_fails_when_HTTPHeaders_ReplaceHeaderNameValuePair_fails_2)
1125 {
1126 /// arrange
1127 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
1128 HTTPAPIEX_RESULT result;
1129
1130 unsigned int httpStatusCode;
1131 HTTP_HEADERS_HANDLE requestHttpHeaders;
1132 HTTP_HEADERS_HANDLE responseHttpHeaders;
1133 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
1134 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1135 umock_c_reset_all_calls();
1136
1137 STRICT_EXPECTED_CALL(BUFFER_new()); /*because it makes a fake buffer*/
1138
1139 STRICT_EXPECTED_CALL(HTTPHeaders_Alloc()); /*because it makes fakes request headers*/
1140 /*this is building the host and content-length for the http request headers*/
1141 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1142 .IgnoreArgument(1).SetReturn(TEST_BUFFER_SIZE);
1143 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, TEST_BUFFER_SIZE))
1144 .IgnoreArgument(1).IgnoreArgument(2);
1145 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1146 .IgnoreArgument(1);
1147 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
1148 .IgnoreArgument(1)
1149 .SetReturn(HTTP_HEADERS_ERROR);
1150
1151 STRICT_EXPECTED_CALL(HTTPHeaders_Free(IGNORED_PTR_ARG))
1152 .IgnoreArgument(1);
1153 STRICT_EXPECTED_CALL(BUFFER_delete(IGNORED_PTR_ARG))
1154 .IgnoreArgument(1);
1155
1156 /// act
1157 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, NULL, NULL, &httpStatusCode, responseHttpHeaders, responseHttpBody);
1158
1159 ///assert
1160 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_ERROR, result);
1161 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1162
1163 ///destroy
1164 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1165 HTTPAPIEX_Destroy(httpapiexhandle);
1166 }
1167
1168 /*Tests_SRS_HTTPAPIEX_02_010: [If any of the operations in SRS_HTTAPIEX_02_009 fails, then HTTPAPIEX_ExecuteRequest shall return HTTPAPIEX_ERROR.]*/
1169 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_NULL_request_headers_and_NULL_requestBody_fails_when_HTTPHeaders_ReplaceHeaderNameValuePair_fails_3)
1170 {
1171 /// arrange
1172 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
1173 HTTPAPIEX_RESULT result;
1174
1175 unsigned int httpStatusCode;
1176 HTTP_HEADERS_HANDLE requestHttpHeaders;
1177 HTTP_HEADERS_HANDLE responseHttpHeaders;
1178 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
1179 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1180 umock_c_reset_all_calls();
1181
1182 STRICT_EXPECTED_CALL(BUFFER_new()); /*because it makes a fake buffer*/
1183
1184 STRICT_EXPECTED_CALL(HTTPHeaders_Alloc())
1185 .SetReturn(NULL); /*because it makes fakes request headers*/
1186
1187 STRICT_EXPECTED_CALL(BUFFER_delete(IGNORED_PTR_ARG))
1188 .IgnoreArgument(1);
1189
1190 /// act
1191 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, NULL, NULL, &httpStatusCode, responseHttpHeaders, responseHttpBody);
1192
1193 ///assert
1194 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_ERROR, result);
1195 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1196
1197 ///destroy
1198 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1199 HTTPAPIEX_Destroy(httpapiexhandle);
1200 }
1201
1202 /*Tests_SRS_HTTPAPIEX_02_011: [If parameter requestHttpHeadersHandle is not NULL then HTTPAPIEX_ExecuteRequest shall create or update the following headers of the request:
1203 Host:{hostname}
1204 Content-Length:the size of the requestContent parameter, and shall use the so constructed HTTPHEADERS object to all calls to HTTPAPI_ExecuteRequest as parameter httpHeadersHandle.]
1205 */
1206 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_non_NULL_request_headers_and_NULL_requestBody_succeeds)
1207 {
1208 /// arrange
1209 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
1210 HTTPAPIEX_RESULT result;
1211
1212 unsigned int httpStatusCode;
1213 HTTP_HEADERS_HANDLE requestHttpHeaders;
1214 HTTP_HEADERS_HANDLE responseHttpHeaders;
1215 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
1216 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1217 umock_c_reset_all_calls();
1218
1219 STRICT_EXPECTED_CALL(BUFFER_new()); /*because it makes a fake buffer*/
1220
1221 /*this is building the host and content-length for the http request headers*/
1222 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1223 .IgnoreArgument(1).SetReturn(0);
1224 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, 0))
1225 .IgnoreArgument(1).IgnoreArgument(2);
1226 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1227 .IgnoreArgument(1);
1228 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
1229 .IgnoreArgument(1);
1230 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Content-Length", "0"))
1231 .IgnoreArgument(1);
1232
1233 /*this is getting the buffer content and buffer length to pass to httpapi_executerequest*/
1234 STRICT_EXPECTED_CALL(HTTPAPI_Init());
1235 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1236 .IgnoreArgument(1);
1237 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
1238 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
1239 .IgnoreArgument(1);
1240
1241 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1242 .IgnoreArgument(1).SetReturn(0);
1243 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
1244 .IgnoreArgument(1).SetReturn(NULL);
1245
1246 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
1247 IGNORED_PTR_ARG,
1248 HTTPAPI_REQUEST_HEAD,
1249 TEST_RELATIVE_PATH,
1250 requestHttpHeaders,
1251 IGNORED_PTR_ARG,
1252 0,
1253 IGNORED_PTR_ARG,
1254 responseHttpHeaders,
1255 responseHttpBody))
1256 .IgnoreArgument(1)
1257 .IgnoreArgument(4)
1258 .IgnoreArgument(5)
1259 .IgnoreArgument(7)
1260 ;
1261
1262 STRICT_EXPECTED_CALL(BUFFER_delete(IGNORED_PTR_ARG))
1263 .IgnoreArgument(1);
1264
1265 /// act
1266 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, NULL, &httpStatusCode, responseHttpHeaders, responseHttpBody);
1267
1268 ///assert
1269 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
1270 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1271
1272 ///destroy
1273 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1274 HTTPAPIEX_Destroy(httpapiexhandle);
1275 }
1276
1277 /*Tests_SRS_HTTPAPIEX_02_012: [If any of the operations required for SRS_HTTAPIEX_02_011 fails, then HTTPAPIEX_ExecuteRequest shall return HTTPAPIEX_ERROR.] */
1278 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_non_NULL_request_headers_and_NULL_requestBody_fails_when_HTTPHeaders_ReplaceHeaderNameValuePair_fails_1)
1279 {
1280 /// arrange
1281 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
1282 HTTPAPIEX_RESULT result;
1283
1284 unsigned int httpStatusCode;
1285 HTTP_HEADERS_HANDLE requestHttpHeaders;
1286 HTTP_HEADERS_HANDLE responseHttpHeaders;
1287 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
1288 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1289 umock_c_reset_all_calls();
1290
1291 STRICT_EXPECTED_CALL(BUFFER_new()); /*because it makes a fake buffer*/
1292
1293 /*this is building the host and content-length for the http request headers*/
1294 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1295 .IgnoreArgument(1).SetReturn(0);
1296 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, 0))
1297 .IgnoreArgument(1).IgnoreArgument(2);
1298 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1299 .IgnoreArgument(1);
1300 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
1301 .IgnoreArgument(1);
1302 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Content-Length", "0"))
1303 .IgnoreArgument(1)
1304 .SetReturn(HTTP_HEADERS_ERROR);
1305
1306 STRICT_EXPECTED_CALL(BUFFER_delete(IGNORED_PTR_ARG))
1307 .IgnoreArgument(1);
1308
1309 /// act
1310 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, NULL, &httpStatusCode, responseHttpHeaders, responseHttpBody);
1311
1312 ///assert
1313 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_ERROR, result);
1314 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1315
1316 ///destroy
1317 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1318 HTTPAPIEX_Destroy(httpapiexhandle);
1319 }
1320
1321 /*Tests_SRS_HTTPAPIEX_02_012: [If any of the operations required for SRS_HTTAPIEX_02_011 fails, then HTTPAPIEX_ExecuteRequest shall return HTTPAPIEX_ERROR.] */
1322 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_non_NULL_request_headers_and_NULL_requestBody_fails_when_HTTPHeaders_ReplaceHeaderNameValuePair_fails_2)
1323 {
1324 /// arrange
1325 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
1326 HTTPAPIEX_RESULT result;
1327
1328 unsigned int httpStatusCode;
1329 HTTP_HEADERS_HANDLE requestHttpHeaders;
1330 HTTP_HEADERS_HANDLE responseHttpHeaders;
1331 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
1332 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1333 umock_c_reset_all_calls();
1334
1335 STRICT_EXPECTED_CALL(BUFFER_new()); /*because it makes a fake buffer*/
1336
1337 /*this is building the host and content-length for the http request headers*/
1338 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1339 .IgnoreArgument(1);
1340 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, TEST_BUFFER_SIZE))
1341 .IgnoreArgument(1).IgnoreArgument(2);
1342 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1343 .IgnoreArgument(1);
1344 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
1345 .IgnoreArgument(1)
1346 .SetReturn(HTTP_HEADERS_ERROR);
1347
1348 STRICT_EXPECTED_CALL(BUFFER_delete(IGNORED_PTR_ARG))
1349 .IgnoreArgument(1);
1350
1351 /// act
1352 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, NULL, &httpStatusCode, responseHttpHeaders, responseHttpBody);
1353
1354 ///assert
1355 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_ERROR, result);
1356 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1357
1358 ///destroy
1359 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1360 HTTPAPIEX_Destroy(httpapiexhandle);
1361 }
1362
1363 /*Tests_SRS_HTTPAPIEX_02_012: [If any of the operations required for SRS_HTTAPIEX_02_011 fails, then HTTPAPIEX_ExecuteRequest shall return HTTPAPIEX_ERROR.] */
1364 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_non_NULL_request_headers_and_NULL_requestBody_fails_when_fake_requestbody_creation_fails)
1365 {
1366 /// arrange
1367 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
1368 HTTPAPIEX_RESULT result;
1369
1370 unsigned int httpStatusCode;
1371 HTTP_HEADERS_HANDLE requestHttpHeaders;
1372 HTTP_HEADERS_HANDLE responseHttpHeaders;
1373 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
1374 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1375 umock_c_reset_all_calls();
1376
1377 STRICT_EXPECTED_CALL(BUFFER_new())
1378 .SetReturn(NULL); /*because it makes a fake buffer*/
1379
1380 /// act
1381 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, NULL, &httpStatusCode, responseHttpHeaders, responseHttpBody);
1382
1383 ///assert
1384 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_ERROR, result);
1385 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1386
1387 ///destroy
1388 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1389 HTTPAPIEX_Destroy(httpapiexhandle);
1390 }
1391
1392 /*Tests_SRS_HTTPAPIEX_02_014: [If requestContent is not NULL then its content and its size shall be used for parameters content and contentLength of HTTPAPI_ExecuteRequest.] */
1393 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_non_NULL_request_headers_and_non_NULL_requestBody_succeeds)
1394 {
1395 /// arrange
1396 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
1397 HTTPAPIEX_RESULT result;
1398
1399 unsigned int httpStatusCode;
1400 HTTP_HEADERS_HANDLE requestHttpHeaders;
1401 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
1402 HTTP_HEADERS_HANDLE responseHttpHeaders;
1403 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
1404 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1405 umock_c_reset_all_calls();
1406
1407 /*this is building the host and content-length for the http request headers*/
1408 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1409 .IgnoreArgument(1);
1410 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, TEST_BUFFER_SIZE))
1411 .IgnoreArgument(1).IgnoreArgument(2);
1412 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1413 .IgnoreArgument(1);
1414 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
1415 .IgnoreArgument(1);
1416 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Content-Length", MU_TOSTRING(TEST_BUFFER_SIZE)))
1417 .IgnoreArgument(1);
1418
1419 /*this is getting the buffer content and buffer length to pass to httpapi_executerequest*/
1420 STRICT_EXPECTED_CALL(HTTPAPI_Init());
1421 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1422 .IgnoreArgument(1);
1423 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
1424 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
1425 .IgnoreArgument(1);
1426
1427 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1428 .IgnoreArgument(1);
1429 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
1430 .IgnoreArgument(1);
1431
1432 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
1433 IGNORED_PTR_ARG,
1434 HTTPAPI_REQUEST_HEAD,
1435 TEST_RELATIVE_PATH,
1436 requestHttpHeaders,
1437 IGNORED_PTR_ARG,
1438 TEST_BUFFER_SIZE,
1439 IGNORED_PTR_ARG,
1440 responseHttpHeaders,
1441 responseHttpBody))
1442 .IgnoreArgument(1)
1443 .IgnoreArgument(4)
1444 .IgnoreArgument(5)
1445 .IgnoreArgument(7)
1446 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
1447 ;
1448
1449 /// act
1450 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
1451
1452 ///assert
1453 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
1454 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1455
1456 ///destroy
1457 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1458 HTTPAPIEX_Destroy(httpapiexhandle);
1459 }
1460
1461 /*Tests_SRS_HTTPAPIEX_21_048: [If HTTPAPIEX_Init was called, HTTPAPI_ExecuteRequest shall not call HTTPAPI_Init.] */
1462 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_not_call_HTTPAPI_Init_after_HTTPAPIEX_Init_succeeds)
1463 {
1464 /// arrange
1465 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, HTTPAPIEX_Init());
1466 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
1467 HTTPAPIEX_RESULT result;
1468
1469 unsigned int httpStatusCode;
1470 HTTP_HEADERS_HANDLE requestHttpHeaders;
1471 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
1472 HTTP_HEADERS_HANDLE responseHttpHeaders;
1473 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
1474 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1475 umock_c_reset_all_calls();
1476
1477 /*this is building the host and content-length for the http request headers*/
1478 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1479 .IgnoreArgument(1);
1480 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, TEST_BUFFER_SIZE))
1481 .IgnoreArgument(1).IgnoreArgument(2);
1482 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1483 .IgnoreArgument(1);
1484 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
1485 .IgnoreArgument(1);
1486 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Content-Length", MU_TOSTRING(TEST_BUFFER_SIZE)))
1487 .IgnoreArgument(1);
1488
1489 /*this is getting the buffer content and buffer length to pass to httpapi_executerequest*/
1490 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1491 .IgnoreArgument(1);
1492 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
1493 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
1494 .IgnoreArgument(1);
1495
1496 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1497 .IgnoreArgument(1);
1498 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
1499 .IgnoreArgument(1);
1500
1501 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
1502 IGNORED_PTR_ARG,
1503 HTTPAPI_REQUEST_HEAD,
1504 TEST_RELATIVE_PATH,
1505 requestHttpHeaders,
1506 IGNORED_PTR_ARG,
1507 TEST_BUFFER_SIZE,
1508 IGNORED_PTR_ARG,
1509 responseHttpHeaders,
1510 responseHttpBody))
1511 .IgnoreArgument(1)
1512 .IgnoreArgument(4)
1513 .IgnoreArgument(5)
1514 .IgnoreArgument(7)
1515 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
1516 ;
1517
1518 /// act
1519 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
1520
1521 ///assert
1522 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
1523 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1524
1525 ///destroy
1526 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1527 HTTPAPIEX_Destroy(httpapiexhandle);
1528 HTTPAPIEX_Deinit();
1529 }
1530
1531 /*Tests_SRS_HTTPAPIEX_21_049: [If HTTPAPIEX_Init was called, HTTPAPI_ExecuteRequest shall not call HTTPAPI_Deinit.] */
1532 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_not_call_HTTPAPI_Deinit_after_HTTPAPIEX_Init_succeeds) /*refer to httpapiex_retry_mechanism.vsdx*/
1533 {
1534 /// arrange
1535 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, HTTPAPIEX_Init());
1536 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
1537 HTTPAPIEX_RESULT result;
1538
1539 unsigned int httpStatusCode;
1540 unsigned int asGivenByHttpApi = 23;
1541 HTTP_HEADERS_HANDLE requestHttpHeaders;
1542 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
1543 HTTP_HEADERS_HANDLE responseHttpHeaders;
1544 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
1545 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1546 (void)HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
1547 umock_c_reset_all_calls();
1548
1549 prepareHTTPAPIEX_ExecuteRequest(&asGivenByHttpApi, requestHttpHeaders, responseHttpHeaders, responseHttpBody, HTTPAPI_ERROR);
1550
1551 {
1552 STRICT_EXPECTED_CALL(HTTPAPI_CloseConnection(IGNORED_PTR_ARG))
1553 .IgnoreArgument(1);
1554
1555 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1556 .IgnoreArgument(1);
1557 whenShallHTTPAPI_CreateConnection_fail[0] = currentHTTPAPI_CreateConnection_call + 1;
1558 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
1559 }
1560
1561 {
1562 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1563 .IgnoreArgument(1);
1564 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
1565 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
1566 .IgnoreArgument(1);
1567 }
1568
1569 {
1570 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1571 .IgnoreArgument(1);
1572 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
1573 .IgnoreArgument(1);
1574 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
1575 IGNORED_PTR_ARG,
1576 HTTPAPI_REQUEST_HEAD,
1577 TEST_RELATIVE_PATH,
1578 requestHttpHeaders,
1579 IGNORED_PTR_ARG,
1580 TEST_BUFFER_SIZE,
1581 IGNORED_PTR_ARG,
1582 responseHttpHeaders,
1583 responseHttpBody))
1584 .IgnoreArgument(1)
1585 .IgnoreArgument(4)
1586 .IgnoreArgument(5)
1587 .IgnoreArgument(7)
1588 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
1589 .CopyOutArgumentBuffer(7, &asGivenByHttpApi, sizeof(asGivenByHttpApi))
1590 ;
1591 }
1592
1593 /// act
1594 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
1595
1596 ///assert
1597 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
1598 ASSERT_ARE_EQUAL(int, 23, (int)httpStatusCode);
1599 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1600
1601 ///destroy
1602 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1603 HTTPAPIEX_Destroy(httpapiexhandle);
1604 HTTPAPIEX_Deinit();
1605 }
1606
1607 /*Tests_SRS_HTTPAPIEX_02_014: [If requestContent is not NULL then its content and its size shall be used for parameters content and contentLength of HTTPAPI_ExecuteRequest.] */
1608 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_non_NULL_request_headers_and_non_NULL_requestBody_fails_when_HTTPHeaders_ReplaceHeaderNameValuePair_fails_1)
1609 {
1610 /// arrange
1611 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
1612 HTTPAPIEX_RESULT result;
1613
1614 unsigned int httpStatusCode;
1615 HTTP_HEADERS_HANDLE requestHttpHeaders;
1616 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
1617 HTTP_HEADERS_HANDLE responseHttpHeaders;
1618 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
1619 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1620 umock_c_reset_all_calls();
1621
1622 /*this is building the host and content-length for the http request headers*/
1623 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1624 .IgnoreArgument(1);
1625 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, TEST_BUFFER_SIZE))
1626 .IgnoreArgument(1).IgnoreArgument(2);
1627 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1628 .IgnoreArgument(1);
1629 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
1630 .IgnoreArgument(1);
1631 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Content-Length", MU_TOSTRING(TEST_BUFFER_SIZE)))
1632 .IgnoreArgument(1)
1633 .SetReturn(HTTP_HEADERS_ERROR);
1634
1635 /// act
1636 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
1637
1638 ///assert
1639 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_ERROR, result);
1640 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1641
1642 ///destroy
1643 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1644 HTTPAPIEX_Destroy(httpapiexhandle);
1645 }
1646
1647 /*Tests_SRS_HTTPAPIEX_02_014: [If requestContent is not NULL then its content and its size shall be used for parameters content and contentLength of HTTPAPI_ExecuteRequest.] */
1648 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_non_NULL_request_headers_and_non_NULL_requestBody_fails_when_HTTPHeaders_ReplaceHeaderNameValuePair_fails_2)
1649 {
1650 /// arrange
1651 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
1652 HTTPAPIEX_RESULT result;
1653
1654 unsigned int httpStatusCode;
1655 HTTP_HEADERS_HANDLE requestHttpHeaders;
1656 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
1657 HTTP_HEADERS_HANDLE responseHttpHeaders;
1658 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
1659 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1660 umock_c_reset_all_calls();
1661
1662 /*this is building the host and content-length for the http request headers*/
1663 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1664 .IgnoreArgument(1);
1665 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, TEST_BUFFER_SIZE))
1666 .IgnoreArgument(1).IgnoreArgument(2);
1667 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1668 .IgnoreArgument(1);
1669 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
1670 .IgnoreArgument(1)
1671 .SetReturn(HTTP_HEADERS_ERROR);
1672
1673 /// act
1674 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
1675
1676 ///assert
1677 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_ERROR, result);
1678 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1679
1680 ///destroy
1681 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1682 HTTPAPIEX_Destroy(httpapiexhandle);
1683 }
1684
1685 /*Tests_SRS_HTTPAPIEX_02_015: [If statusCode is NULL then HTTPAPIEX_ExecuteRequest shall not write in statusCode the HTTP status code, and it will use a temporary internal int for parameter statusCode to the calls of HTTPAPI_ExecuteRequest.] */
1686 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_NULL_statusCode_succeeds)
1687 {
1688 /// arrange
1689 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
1690 HTTPAPIEX_RESULT result;
1691
1692 HTTP_HEADERS_HANDLE requestHttpHeaders;
1693 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
1694 HTTP_HEADERS_HANDLE responseHttpHeaders;
1695 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
1696 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1697 umock_c_reset_all_calls();
1698
1699 /*this is building the host and content-length for the http request headers*/
1700 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1701 .IgnoreArgument(1).SetReturn(TEST_BUFFER_SIZE);
1702 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, TEST_BUFFER_SIZE))
1703 .IgnoreArgument(1).IgnoreArgument(2);
1704 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1705 .IgnoreArgument(1);
1706 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
1707 .IgnoreArgument(1);
1708 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Content-Length", MU_TOSTRING(TEST_BUFFER_SIZE)))
1709 .IgnoreArgument(1);
1710
1711 /*this is getting the buffer content and buffer length to pass to httpapi_executerequest*/
1712 STRICT_EXPECTED_CALL(HTTPAPI_Init());
1713 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1714 .IgnoreArgument(1);
1715 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
1716 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
1717 .IgnoreArgument(1);
1718
1719 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1720 .IgnoreArgument(1);
1721 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
1722 .IgnoreArgument(1);
1723
1724 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
1725 IGNORED_PTR_ARG,
1726 HTTPAPI_REQUEST_HEAD,
1727 TEST_RELATIVE_PATH,
1728 requestHttpHeaders,
1729 IGNORED_PTR_ARG,
1730 TEST_BUFFER_SIZE,
1731 IGNORED_PTR_ARG,
1732 responseHttpHeaders,
1733 responseHttpBody))
1734 .IgnoreArgument(1)
1735 .IgnoreArgument(4)
1736 .IgnoreArgument(5)
1737 .IgnoreArgument(7)
1738 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
1739 ;
1740
1741 /// act
1742 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, NULL, responseHttpHeaders, responseHttpBody);
1743
1744 ///assert
1745 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
1746 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1747
1748 ///destroy
1749 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1750 HTTPAPIEX_Destroy(httpapiexhandle);
1751 }
1752
1753 /*Tests_SRS_HTTPAPIEX_02_016: [If statusCode is not NULL then If statusCode is NULL then HTTPAPIEX_ExecuteRequest shall use it for parameter statusCode to the calls of HTTPAPI_ExecuteRequest.] */
1754 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_non_NULL_statusCode_returns_that_code_to_the_caller_suceeds)
1755 {
1756 /// arrange
1757 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
1758 HTTPAPIEX_RESULT result;
1759
1760 unsigned int httpStatusCode;
1761 unsigned int asGivenByHttpApi = 4567;
1762 HTTP_HEADERS_HANDLE requestHttpHeaders;
1763 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
1764 HTTP_HEADERS_HANDLE responseHttpHeaders;
1765 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
1766 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1767 umock_c_reset_all_calls();
1768
1769 /*this is building the host and content-length for the http request headers*/
1770 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1771 .IgnoreArgument(1).SetReturn(TEST_BUFFER_SIZE);
1772 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, TEST_BUFFER_SIZE))
1773 .IgnoreArgument(1).IgnoreArgument(2);
1774 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1775 .IgnoreArgument(1);
1776 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
1777 .IgnoreArgument(1);
1778 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Content-Length", MU_TOSTRING(TEST_BUFFER_SIZE)))
1779 .IgnoreArgument(1);
1780
1781 /*this is getting the buffer content and buffer length to pass to httpapi_executerequest*/
1782 STRICT_EXPECTED_CALL(HTTPAPI_Init());
1783 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1784 .IgnoreArgument(1);
1785 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
1786 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
1787 .IgnoreArgument(1);
1788
1789 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1790 .IgnoreArgument(1);
1791 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
1792 .IgnoreArgument(1);
1793
1794 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
1795 IGNORED_PTR_ARG,
1796 HTTPAPI_REQUEST_HEAD,
1797 TEST_RELATIVE_PATH,
1798 requestHttpHeaders,
1799 IGNORED_PTR_ARG,
1800 TEST_BUFFER_SIZE,
1801 IGNORED_PTR_ARG,
1802 responseHttpHeaders,
1803 responseHttpBody))
1804 .IgnoreArgument(1)
1805 .IgnoreArgument(4)
1806 .IgnoreArgument(5)
1807 .IgnoreArgument(7)
1808 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
1809 .CopyOutArgumentBuffer(7, &asGivenByHttpApi, sizeof(asGivenByHttpApi))
1810 ;
1811
1812 /// act
1813 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
1814
1815 ///assert
1816 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
1817 ASSERT_ARE_EQUAL(int, 4567, (int)httpStatusCode);
1818 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1819
1820 ///destroy
1821 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1822 HTTPAPIEX_Destroy(httpapiexhandle);
1823 }
1824
1825 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_cleans_when_originalhttpbody_is_NULL_and_response_headers_fails)
1826 {
1827 /// arrange
1828 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
1829 HTTPAPIEX_RESULT result;
1830
1831 unsigned int httpStatusCode;
1832 HTTP_HEADERS_HANDLE requestHttpHeaders;
1833 HTTP_HEADERS_HANDLE responseHttpHeaders;
1834 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
1835 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1836 umock_c_reset_all_calls();
1837
1838 STRICT_EXPECTED_CALL(BUFFER_new()); /*because it makes a fake buffer*/
1839
1840 STRICT_EXPECTED_CALL(HTTPHeaders_Alloc());
1841
1842 /*this is building the host and content-length for the http request headers*/
1843 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1844 .IgnoreArgument(1).SetReturn(0);
1845 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, 0))
1846 .IgnoreArgument(1).IgnoreArgument(2);
1847 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1848 .IgnoreArgument(1);
1849 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
1850 .IgnoreArgument(1);
1851 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Content-Length", "0"))
1852 .IgnoreArgument(1);
1853
1854 /*Because it is creating fake response headers*/
1855 STRICT_EXPECTED_CALL(HTTPHeaders_Alloc())
1856 .SetReturn(NULL);
1857
1858 STRICT_EXPECTED_CALL(BUFFER_delete(IGNORED_PTR_ARG))
1859 .IgnoreArgument(1);
1860 STRICT_EXPECTED_CALL(HTTPHeaders_Free(IGNORED_PTR_ARG))
1861 .IgnoreArgument(1);
1862
1863 /// act
1864 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, NULL, NULL, &httpStatusCode, NULL, responseHttpBody);
1865
1866 ///assert
1867 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_ERROR, result);
1868 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1869
1870 ///destroy
1871 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1872 HTTPAPIEX_Destroy(httpapiexhandle);
1873 }
1874
1875 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_cleans_when_responsehttpbody_is_NULL_and_creating_a_fake_one_fails)
1876 {
1877 /// arrange
1878 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
1879 HTTPAPIEX_RESULT result;
1880
1881 unsigned int httpStatusCode;
1882 HTTP_HEADERS_HANDLE requestHttpHeaders;
1883 HTTP_HEADERS_HANDLE responseHttpHeaders;
1884 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1885 umock_c_reset_all_calls();
1886
1887 STRICT_EXPECTED_CALL(BUFFER_new()); /*because it makes a fake buffer*/
1888
1889 STRICT_EXPECTED_CALL(HTTPHeaders_Alloc());
1890
1891 /*this is building the host and content-length for the http request headers*/
1892 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1893 .IgnoreArgument(1).SetReturn(0);
1894 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, 0))
1895 .IgnoreArgument(1).IgnoreArgument(2);
1896 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1897 .IgnoreArgument(1);
1898 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
1899 .IgnoreArgument(1);
1900 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Content-Length", "0"))
1901 .IgnoreArgument(1);
1902
1903 /*Because it is creating fake response headers*/
1904 STRICT_EXPECTED_CALL(HTTPHeaders_Alloc());
1905
1906 STRICT_EXPECTED_CALL(BUFFER_new())
1907 .SetReturn(NULL); /*because it makes a fake buffer*/
1908
1909 STRICT_EXPECTED_CALL(BUFFER_delete(IGNORED_PTR_ARG))
1910 .IgnoreArgument(1);
1911 STRICT_EXPECTED_CALL(HTTPHeaders_Free(IGNORED_PTR_ARG))
1912 .IgnoreArgument(1);
1913 STRICT_EXPECTED_CALL(HTTPHeaders_Free(IGNORED_PTR_ARG))
1914 .IgnoreArgument(1);
1915
1916 /// act
1917 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, NULL, NULL, &httpStatusCode, NULL, NULL);
1918
1919 ///assert
1920 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_ERROR, result);
1921 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1922
1923 ///destroy
1924 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1925 HTTPAPIEX_Destroy(httpapiexhandle);
1926 }
1927
1928 /*Tests_SRS_HTTPAPIEX_02_017: [If responseHeaders handle is NULL then HTTPAPIEX_ExecuteRequest shall create a temporary internal instance of HTTPHEADERS object and use that for responseHeaders parameter of HTTPAPI_ExecuteRequest call.] */
1929 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_NULL_response_headers_suceeds)
1930 {
1931 /// arrange
1932 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
1933 HTTPAPIEX_RESULT result;
1934
1935 unsigned int httpStatusCode;
1936 unsigned int asGivenByHttpApi = 4567;
1937 HTTP_HEADERS_HANDLE requestHttpHeaders;
1938 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
1939 HTTP_HEADERS_HANDLE responseHttpHeaders;
1940 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
1941 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
1942 umock_c_reset_all_calls();
1943
1944 /*this is building the host and content-length for the http request headers*/
1945 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1946 .IgnoreArgument(1);
1947 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, TEST_BUFFER_SIZE))
1948 .IgnoreArgument(1).IgnoreArgument(2);
1949 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1950 .IgnoreArgument(1);
1951 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
1952 .IgnoreArgument(1);
1953 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Content-Length", MU_TOSTRING(TEST_BUFFER_SIZE)))
1954 .IgnoreArgument(1);
1955
1956 /*Because it is creating fake response headers*/
1957 STRICT_EXPECTED_CALL(HTTPHeaders_Alloc());
1958
1959 /*this is getting the buffer content and buffer length to pass to httpapi_executerequest*/
1960 STRICT_EXPECTED_CALL(HTTPAPI_Init());
1961 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
1962 .IgnoreArgument(1);
1963 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
1964 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
1965 .IgnoreArgument(1);
1966
1967 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
1968 .IgnoreArgument(1);
1969 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
1970 .IgnoreArgument(1);
1971
1972 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
1973 IGNORED_PTR_ARG,
1974 HTTPAPI_REQUEST_HEAD,
1975 TEST_RELATIVE_PATH,
1976 requestHttpHeaders,
1977 IGNORED_PTR_ARG,
1978 TEST_BUFFER_SIZE,
1979 IGNORED_PTR_ARG,
1980 IGNORED_PTR_ARG,
1981 responseHttpBody))
1982 .IgnoreArgument(1)
1983 .IgnoreArgument(4)
1984 .IgnoreArgument(5)
1985 .IgnoreArgument(7)
1986 .IgnoreArgument(8)
1987 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
1988 .CopyOutArgumentBuffer(7, &asGivenByHttpApi, sizeof(asGivenByHttpApi))
1989 ;
1990
1991 STRICT_EXPECTED_CALL(HTTPHeaders_Free(IGNORED_PTR_ARG))
1992 .IgnoreArgument(1);
1993
1994 /// act
1995 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, NULL, responseHttpBody);
1996
1997 ///assert
1998 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
1999 ASSERT_ARE_EQUAL(int, 4567, (int)httpStatusCode);
2000 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2001
2002 ///destroy
2003 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2004 HTTPAPIEX_Destroy(httpapiexhandle);
2005 }
2006
2007 /*Tests_SRS_HTTPAPIEX_02_018: [If creating the temporary http headers in SRS_HTTPAPIEX_02_017 fails then HTTPAPIEX_ExecuteRequest shall return HTTPAPIEX_ERROR.] */
2008 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_NULL_response_headers_fails_when_HTTPHeaders_Alloc_fails)
2009 {
2010 /// arrange
2011 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
2012 HTTPAPIEX_RESULT result;
2013
2014 unsigned int httpStatusCode;
2015 HTTP_HEADERS_HANDLE requestHttpHeaders;
2016 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
2017 HTTP_HEADERS_HANDLE responseHttpHeaders;
2018 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
2019 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2020 umock_c_reset_all_calls();
2021
2022 /*this is building the host and content-length for the http request headers*/
2023 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
2024 .IgnoreArgument(1);
2025 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, TEST_BUFFER_SIZE))
2026 .IgnoreArgument(1).IgnoreArgument(2);
2027 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2028 .IgnoreArgument(1);
2029 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
2030 .IgnoreArgument(1);
2031 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Content-Length", MU_TOSTRING(TEST_BUFFER_SIZE)))
2032 .IgnoreArgument(1);
2033
2034 /*Because it is creating fake response headers*/
2035 STRICT_EXPECTED_CALL(HTTPHeaders_Alloc())
2036 .SetReturn(NULL);
2037
2038 /// act
2039 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, NULL, responseHttpBody);
2040
2041 ///assert
2042 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_ERROR, result);
2043 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2044
2045 ///destroy
2046 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2047 HTTPAPIEX_Destroy(httpapiexhandle);
2048 }
2049
2050 /*Tests_SRS_HTTPAPIEX_02_019: [If responseHeaders is not NULL, then then HTTPAPIEX_ExecuteRequest shall use that object as parameter responseHeaders of HTTPAPI_ExecuteRequest call.] */
2051 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_non_NULL_response_headers_suceeds)
2052 {
2053 /// arrange
2054 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
2055 HTTPAPIEX_RESULT result;
2056
2057 unsigned int httpStatusCode;
2058 unsigned int asGivenByHttpApi = 4567;
2059 HTTP_HEADERS_HANDLE requestHttpHeaders;
2060 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
2061 HTTP_HEADERS_HANDLE responseHttpHeaders;
2062 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
2063 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2064 umock_c_reset_all_calls();
2065
2066 /*this is building the host and content-length for the http request headers*/
2067 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
2068 .IgnoreArgument(1);
2069 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, TEST_BUFFER_SIZE))
2070 .IgnoreArgument(1).IgnoreArgument(2);
2071 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2072 .IgnoreArgument(1);
2073 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
2074 .IgnoreArgument(1);
2075 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Content-Length", MU_TOSTRING(TEST_BUFFER_SIZE)))
2076 .IgnoreArgument(1);
2077
2078 /*this is getting the buffer content and buffer length to pass to httpapi_executerequest*/
2079 STRICT_EXPECTED_CALL(HTTPAPI_Init());
2080 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2081 .IgnoreArgument(1);
2082 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
2083 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
2084 .IgnoreArgument(1);
2085
2086 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
2087 .IgnoreArgument(1).SetReturn(TEST_BUFFER_SIZE);
2088 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
2089 .IgnoreArgument(1).SetReturn(TEST_BUFFER);
2090
2091 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
2092 IGNORED_PTR_ARG,
2093 HTTPAPI_REQUEST_HEAD,
2094 TEST_RELATIVE_PATH,
2095 requestHttpHeaders,
2096 IGNORED_PTR_ARG,
2097 TEST_BUFFER_SIZE,
2098 IGNORED_PTR_ARG,
2099 responseHttpHeaders,
2100 responseHttpBody))
2101 .IgnoreArgument(1)
2102 .IgnoreArgument(5)
2103 .IgnoreArgument(7)
2104 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
2105 .CopyOutArgumentBuffer(7, &asGivenByHttpApi, sizeof(asGivenByHttpApi))
2106 ;
2107
2108 /// act
2109 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2110
2111 ///assert
2112 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
2113 ASSERT_ARE_EQUAL(int, 4567, (int)httpStatusCode);
2114 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2115
2116 ///destroy
2117 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2118 HTTPAPIEX_Destroy(httpapiexhandle);
2119 }
2120
2121 /*Tests_SRS_HTTPAPIEX_02_020: [If responseContent is NULL then HTTPAPIEX_ExecuteRequest shall create a temporary internal BUFFER object and use that as parameter responseContent of HTTPAPI_ExecuteRequest call.] */
2122 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_NULL_response_body_suceeds)
2123 {
2124 /// arrange
2125 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
2126 HTTPAPIEX_RESULT result;
2127
2128 unsigned int httpStatusCode;
2129 unsigned int asGivenByHttpApi = 4567;
2130 HTTP_HEADERS_HANDLE requestHttpHeaders;
2131 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
2132 HTTP_HEADERS_HANDLE responseHttpHeaders;
2133 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2134 umock_c_reset_all_calls();
2135
2136 /*this is building the host and content-length for the http request headers*/
2137 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
2138 .IgnoreArgument(1);
2139 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, TEST_BUFFER_SIZE))
2140 .IgnoreArgument(1).IgnoreArgument(2);
2141 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2142 .IgnoreArgument(1);
2143 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
2144 .IgnoreArgument(1);
2145 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Content-Length", MU_TOSTRING(TEST_BUFFER_SIZE)))
2146 .IgnoreArgument(1);
2147
2148 STRICT_EXPECTED_CALL(BUFFER_new()); /*because it makes a fake response buffer*/
2149
2150 /*this is getting the buffer content and buffer length to pass to httpapi_executerequest*/
2151 STRICT_EXPECTED_CALL(HTTPAPI_Init());
2152 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2153 .IgnoreArgument(1);
2154 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
2155 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
2156 .IgnoreArgument(1);
2157
2158 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
2159 .IgnoreArgument(1).SetReturn(TEST_BUFFER_SIZE);
2160 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
2161 .IgnoreArgument(1).SetReturn(TEST_BUFFER);
2162
2163 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
2164 IGNORED_PTR_ARG,
2165 HTTPAPI_REQUEST_HEAD,
2166 TEST_RELATIVE_PATH,
2167 requestHttpHeaders,
2168 IGNORED_PTR_ARG,
2169 TEST_BUFFER_SIZE,
2170 IGNORED_PTR_ARG,
2171 responseHttpHeaders,
2172 IGNORED_PTR_ARG))
2173 .IgnoreArgument(1)
2174 .IgnoreArgument(4)
2175 .IgnoreArgument(5)
2176 .IgnoreArgument(7)
2177 .IgnoreArgument(9)
2178 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
2179 .CopyOutArgumentBuffer(7, &asGivenByHttpApi, sizeof(asGivenByHttpApi))
2180 ;
2181
2182 STRICT_EXPECTED_CALL(BUFFER_delete(IGNORED_PTR_ARG))
2183 .IgnoreArgument(1);
2184
2185 /// act
2186 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, NULL);
2187
2188 ///assert
2189 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
2190 ASSERT_ARE_EQUAL(int, 4567, (int)httpStatusCode);
2191 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2192
2193 ///destroy
2194 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2195 HTTPAPIEX_Destroy(httpapiexhandle);
2196 }
2197
2198 /*Tests_SRS_HTTPAPIEX_02_021: [If creating the BUFFER_HANDLE in SRS_HTTPAPIEX_02_020 fails, then HTTPAPIEX_ExecuteRequest shall return HTTPAPIEX_ERROR.] */
2199 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_NULL_fails_when_BUFFER_new_fails)
2200 {
2201 /// arrange
2202 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
2203 HTTPAPIEX_RESULT result;
2204
2205 unsigned int httpStatusCode;
2206 HTTP_HEADERS_HANDLE requestHttpHeaders;
2207 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
2208 HTTP_HEADERS_HANDLE responseHttpHeaders;
2209 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2210 umock_c_reset_all_calls();
2211
2212 /*this is building the host and content-length for the http request headers*/
2213 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
2214 .IgnoreArgument(1);
2215 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, TEST_BUFFER_SIZE))
2216 .IgnoreArgument(1).IgnoreArgument(2);
2217 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2218 .IgnoreArgument(1);
2219 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
2220 .IgnoreArgument(1);
2221 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Content-Length", MU_TOSTRING(TEST_BUFFER_SIZE)))
2222 .IgnoreArgument(1);
2223
2224 STRICT_EXPECTED_CALL(BUFFER_new())
2225 .SetReturn(NULL); /*because it makes a fake response buffer*/
2226
2227 /// act
2228 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, NULL);
2229
2230 ///assert
2231 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_ERROR, result);
2232 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2233
2234 ///destroy
2235 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2236 HTTPAPIEX_Destroy(httpapiexhandle);
2237 }
2238
2239 /*Tests_SRS_HTTPAPIEX_02_022: [If responseContent is not NULL then HTTPAPIEX_ExecuteRequest use that as parameter responseContent of HTTPAPI_ExecuteRequest call.] */
2240 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_with_non_NULL_response_body_suceeds)
2241 {
2242 /// arrange
2243 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
2244 HTTPAPIEX_RESULT result;
2245
2246 unsigned int httpStatusCode;
2247 unsigned int asGivenByHttpApi = 4567;
2248 HTTP_HEADERS_HANDLE requestHttpHeaders;
2249 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
2250 HTTP_HEADERS_HANDLE responseHttpHeaders;
2251 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
2252 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2253 umock_c_reset_all_calls();
2254
2255 /*this is building the host and content-length for the http request headers*/
2256 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
2257 .IgnoreArgument(1);
2258 STRICT_EXPECTED_CALL(size_tToString(IGNORED_PTR_ARG, IGNORED_NUM_ARG, TEST_BUFFER_SIZE))
2259 .IgnoreArgument(1).IgnoreArgument(2);
2260 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2261 .IgnoreArgument(1);
2262 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Host", TEST_HOSTNAME))
2263 .IgnoreArgument(1);
2264 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, "Content-Length", MU_TOSTRING(TEST_BUFFER_SIZE)))
2265 .IgnoreArgument(1);
2266
2267 /*this is getting the buffer content and buffer length to pass to httpapi_executerequest*/
2268 STRICT_EXPECTED_CALL(HTTPAPI_Init());
2269 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2270 .IgnoreArgument(1);
2271 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
2272 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
2273 .IgnoreArgument(1);
2274
2275 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
2276 .IgnoreArgument(1);
2277 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
2278 .IgnoreArgument(1);
2279
2280 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
2281 IGNORED_PTR_ARG,
2282 HTTPAPI_REQUEST_HEAD,
2283 TEST_RELATIVE_PATH,
2284 requestHttpHeaders,
2285 IGNORED_PTR_ARG,
2286 TEST_BUFFER_SIZE,
2287 IGNORED_PTR_ARG,
2288 responseHttpHeaders,
2289 responseHttpBody))
2290 .IgnoreArgument(1)
2291 .IgnoreArgument(4)
2292 .IgnoreArgument(5)
2293 .IgnoreArgument(7)
2294 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
2295 .CopyOutArgumentBuffer(7, &asGivenByHttpApi, sizeof(asGivenByHttpApi))
2296 ;
2297
2298 /// act
2299 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2300
2301 ///assert
2302 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
2303 ASSERT_ARE_EQUAL(int, 4567, (int)httpStatusCode);
2304 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2305
2306 ///destroy
2307 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2308 HTTPAPIEX_Destroy(httpapiexhandle);
2309 }
2310
2311 /*Tests_SRS_HTTPAPIEX_02_023: [HTTPAPIEX_ExecuteRequest shall try to execute the HTTP call by ensuring the following API call sequence is respected:]*/
2312 /*Tests_SRS_HTTPAPIEX_02_024: [If any point in the sequence fails, HTTPAPIEX_ExecuteRequest shall attempt to recover by going back to the previous step and retrying that step.]*/
2313 /*Tests_SRS_HTTPAPIEX_02_025: [If the first step fails, then the sequence fails.]*/
2314 /*Tests_SRS_HTTPAPIEX_02_026: [A step shall be retried at most once.]*/
2315 /*Tests_SRS_HTTPAPIEX_02_027: [If a step has been retried then all subsequent steps shall be retried too.]*/
2316 /*Tests_SRS_HTTPAPIEX_02_028: [HTTPAPIEX_ExecuteRequest shall return HTTPAPIEX_OK when a call to HTTPAPI_ExecuteRequest has been completed successfully.]*/
2317 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_TestCase_S1) /*refer to httpapiex_retry_mechanism.vsdx*/
2318 {
2319 /// arrange
2320 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
2321 HTTPAPIEX_RESULT result;
2322
2323 unsigned int httpStatusCode;
2324 unsigned int asGivenByHttpApi = 23;
2325 HTTP_HEADERS_HANDLE requestHttpHeaders;
2326 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
2327 HTTP_HEADERS_HANDLE responseHttpHeaders;
2328 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
2329 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2330 (void)HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2331 umock_c_reset_all_calls();
2332
2333 prepareHTTPAPIEX_ExecuteRequest(&asGivenByHttpApi, requestHttpHeaders, responseHttpHeaders, responseHttpBody, HTTPAPI_OK);
2334
2335 /// act
2336 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2337
2338 ///assert
2339 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
2340 ASSERT_ARE_EQUAL(int, 23, (int)httpStatusCode);
2341 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2342
2343 ///destroy
2344 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2345 HTTPAPIEX_Destroy(httpapiexhandle);
2346 }
2347
2348 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_TestCase_S2) /*refer to httpapiex_retry_mechanism.vsdx*/
2349 {
2350 /// arrange
2351 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
2352 HTTPAPIEX_RESULT result;
2353
2354 unsigned int httpStatusCode;
2355 unsigned int asGivenByHttpApi = 23;
2356 HTTP_HEADERS_HANDLE requestHttpHeaders;
2357 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
2358 HTTP_HEADERS_HANDLE responseHttpHeaders;
2359 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
2360 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2361 (void)HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2362 umock_c_reset_all_calls();
2363
2364 prepareHTTPAPIEX_ExecuteRequest(&asGivenByHttpApi, requestHttpHeaders, responseHttpHeaders, responseHttpBody, HTTPAPI_ERROR);
2365
2366 {
2367 STRICT_EXPECTED_CALL(HTTPAPI_CloseConnection(IGNORED_PTR_ARG))
2368 .IgnoreArgument(1);
2369
2370 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2371 .IgnoreArgument(1);
2372 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
2373 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
2374 .IgnoreArgument(1);
2375
2376 }
2377
2378 {
2379 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
2380 .IgnoreArgument(1);
2381 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
2382 .IgnoreArgument(1);
2383 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
2384 IGNORED_PTR_ARG,
2385 HTTPAPI_REQUEST_HEAD,
2386 TEST_RELATIVE_PATH,
2387 requestHttpHeaders,
2388 IGNORED_PTR_ARG,
2389 TEST_BUFFER_SIZE,
2390 IGNORED_PTR_ARG,
2391 responseHttpHeaders,
2392 responseHttpBody))
2393 .IgnoreArgument(1)
2394 .IgnoreArgument(4)
2395 .IgnoreArgument(5)
2396 .IgnoreArgument(7)
2397 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
2398 .CopyOutArgumentBuffer(7, &asGivenByHttpApi, sizeof(asGivenByHttpApi))
2399 ;
2400 }
2401 /// act
2402 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2403
2404 ///assert
2405 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
2406 ASSERT_ARE_EQUAL(int, 23, (int)httpStatusCode);
2407 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2408
2409 ///destroy
2410 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2411 HTTPAPIEX_Destroy(httpapiexhandle);
2412 }
2413
2414 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_TestCase_S3) /*refer to httpapiex_retry_mechanism.vsdx*/
2415 {
2416 /// arrange
2417 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
2418 HTTPAPIEX_RESULT result;
2419
2420 unsigned int httpStatusCode;
2421 unsigned int asGivenByHttpApi = 23;
2422 HTTP_HEADERS_HANDLE requestHttpHeaders;
2423 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
2424 HTTP_HEADERS_HANDLE responseHttpHeaders;
2425 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
2426 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2427 (void)HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2428 umock_c_reset_all_calls();
2429
2430 prepareHTTPAPIEX_ExecuteRequest(&asGivenByHttpApi, requestHttpHeaders, responseHttpHeaders, responseHttpBody, HTTPAPI_ERROR);
2431
2432 {
2433 STRICT_EXPECTED_CALL(HTTPAPI_CloseConnection(IGNORED_PTR_ARG))
2434 .IgnoreArgument(1);
2435
2436 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2437 .IgnoreArgument(1);
2438 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
2439 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
2440 .IgnoreArgument(1);
2441 }
2442
2443 {
2444 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
2445 .IgnoreArgument(1);
2446 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
2447 .IgnoreArgument(1);
2448 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
2449 IGNORED_PTR_ARG,
2450 HTTPAPI_REQUEST_HEAD,
2451 TEST_RELATIVE_PATH,
2452 requestHttpHeaders,
2453 IGNORED_PTR_ARG,
2454 TEST_BUFFER_SIZE,
2455 IGNORED_PTR_ARG,
2456 responseHttpHeaders,
2457 responseHttpBody))
2458 .IgnoreArgument(1)
2459 .IgnoreArgument(4)
2460 .IgnoreArgument(5)
2461 .IgnoreArgument(7)
2462 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
2463 .CopyOutArgumentBuffer(7, &asGivenByHttpApi, sizeof(asGivenByHttpApi))
2464 .SetReturn(HTTPAPI_ERROR)
2465 ;
2466 }
2467
2468 {
2469 STRICT_EXPECTED_CALL(HTTPAPI_CloseConnection(IGNORED_PTR_ARG))
2470 .IgnoreArgument(1);
2471 STRICT_EXPECTED_CALL(HTTPAPI_Deinit());
2472 STRICT_EXPECTED_CALL(HTTPAPI_Init())
2473 .SetReturn(HTTPAPI_OK);
2474 }
2475
2476 {
2477 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2478 .IgnoreArgument(1);
2479 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
2480 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
2481 .IgnoreArgument(1);
2482 }
2483
2484 {
2485 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
2486 .IgnoreArgument(1);
2487 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
2488 .IgnoreArgument(1);
2489 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
2490 IGNORED_PTR_ARG,
2491 HTTPAPI_REQUEST_HEAD,
2492 TEST_RELATIVE_PATH,
2493 requestHttpHeaders,
2494 IGNORED_PTR_ARG,
2495 TEST_BUFFER_SIZE,
2496 IGNORED_PTR_ARG,
2497 responseHttpHeaders,
2498 responseHttpBody))
2499 .IgnoreArgument(1)
2500 .IgnoreArgument(4)
2501 .IgnoreArgument(5)
2502 .IgnoreArgument(7)
2503 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
2504 .CopyOutArgumentBuffer(7, &asGivenByHttpApi, sizeof(asGivenByHttpApi))
2505 ;
2506 }
2507
2508 /// act
2509 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2510
2511 ///assert
2512 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
2513 ASSERT_ARE_EQUAL(int, 23, (int)httpStatusCode);
2514 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2515
2516 ///destroy
2517 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2518 HTTPAPIEX_Destroy(httpapiexhandle);
2519 }
2520
2521 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_TestCase_S4) /*refer to httpapiex_retry_mechanism.vsdx*/
2522 {
2523 /// arrange
2524 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
2525 HTTPAPIEX_RESULT result;
2526
2527 unsigned int httpStatusCode;
2528 unsigned int asGivenByHttpApi = 23;
2529 HTTP_HEADERS_HANDLE requestHttpHeaders;
2530 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
2531 HTTP_HEADERS_HANDLE responseHttpHeaders;
2532 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
2533 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2534 (void)HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2535 umock_c_reset_all_calls();
2536
2537 prepareHTTPAPIEX_ExecuteRequest(&asGivenByHttpApi, requestHttpHeaders, responseHttpHeaders, responseHttpBody, HTTPAPI_ERROR);
2538
2539 {
2540 STRICT_EXPECTED_CALL(HTTPAPI_CloseConnection(IGNORED_PTR_ARG))
2541 .IgnoreArgument(1);
2542
2543 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2544 .IgnoreArgument(1);
2545 whenShallHTTPAPI_CreateConnection_fail[0] = currentHTTPAPI_CreateConnection_call + 1;
2546 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
2547 }
2548
2549 {
2550 STRICT_EXPECTED_CALL(HTTPAPI_Deinit());
2551 STRICT_EXPECTED_CALL(HTTPAPI_Init())
2552 .SetReturn(HTTPAPI_OK);
2553 }
2554
2555 {
2556 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2557 .IgnoreArgument(1);
2558 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
2559 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
2560 .IgnoreArgument(1);
2561 }
2562
2563 {
2564 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
2565 .IgnoreArgument(1);
2566 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
2567 .IgnoreArgument(1);
2568 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
2569 IGNORED_PTR_ARG,
2570 HTTPAPI_REQUEST_HEAD,
2571 TEST_RELATIVE_PATH,
2572 requestHttpHeaders,
2573 IGNORED_PTR_ARG,
2574 TEST_BUFFER_SIZE,
2575 IGNORED_PTR_ARG,
2576 responseHttpHeaders,
2577 responseHttpBody))
2578 .IgnoreArgument(1)
2579 .IgnoreArgument(4)
2580 .IgnoreArgument(5)
2581 .IgnoreArgument(7)
2582 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
2583 .CopyOutArgumentBuffer(7, &asGivenByHttpApi, sizeof(asGivenByHttpApi))
2584 ;
2585 }
2586
2587 /// act
2588 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2589
2590 ///assert
2591 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
2592 ASSERT_ARE_EQUAL(int, 23, (int)httpStatusCode);
2593 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2594
2595 ///destroy
2596 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2597 HTTPAPIEX_Destroy(httpapiexhandle);
2598 }
2599
2600 /*this and all subsequent tests... */
2601 /*Tests_SRS_HTTPAPIEX_02_029: [Otherwise, HTTAPIEX_ExecuteRequest shall return HTTPAPIEX_RECOVERYFAILED.] */
2602 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_TestCase_F1) /*refer to httpapiex_retry_mechanism.vsdx*/
2603 {
2604 /// arrange
2605 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
2606 HTTPAPIEX_RESULT result;
2607
2608 unsigned int httpStatusCode;
2609 unsigned int asGivenByHttpApi = 23;
2610 HTTP_HEADERS_HANDLE requestHttpHeaders;
2611 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
2612 HTTP_HEADERS_HANDLE responseHttpHeaders;
2613 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
2614 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2615 (void)HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2616 umock_c_reset_all_calls();
2617
2618 prepareHTTPAPIEX_ExecuteRequest(&asGivenByHttpApi, requestHttpHeaders, responseHttpHeaders, responseHttpBody, HTTPAPI_ERROR);
2619
2620 {
2621 STRICT_EXPECTED_CALL(HTTPAPI_CloseConnection(IGNORED_PTR_ARG))
2622 .IgnoreArgument(1);
2623
2624 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2625 .IgnoreArgument(1);
2626 whenShallHTTPAPI_CreateConnection_fail[0] = currentHTTPAPI_CreateConnection_call + 1;
2627 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
2628 }
2629
2630 {
2631 STRICT_EXPECTED_CALL(HTTPAPI_Deinit());
2632 whenShallHTTPAPI_Init_fail[0] = currentHTTPAPI_Init_call + 1;
2633 STRICT_EXPECTED_CALL(HTTPAPI_Init());
2634 }
2635
2636 /// act
2637 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2638
2639 ///assert
2640 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_RECOVERYFAILED, result);
2641 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2642
2643 ///destroy
2644 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2645 HTTPAPIEX_Destroy(httpapiexhandle);
2646 }
2647
2648 /*Tests_SRS_HTTPAPIEX_02_029: [Otherwise, HTTAPIEX_ExecuteRequest shall return HTTPAPIEX_RECOVERYFAILED.] */
2649 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_TestCase_F2) /*refer to httpapiex_retry_mechanism.vsdx*/
2650 {
2651 /// arrange
2652 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
2653 HTTPAPIEX_RESULT result;
2654
2655 unsigned int httpStatusCode;
2656 unsigned int asGivenByHttpApi = 23;
2657 HTTP_HEADERS_HANDLE requestHttpHeaders;
2658 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
2659 HTTP_HEADERS_HANDLE responseHttpHeaders;
2660 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
2661 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2662 (void)HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2663 umock_c_reset_all_calls();
2664
2665 prepareHTTPAPIEX_ExecuteRequest(&asGivenByHttpApi, requestHttpHeaders, responseHttpHeaders, responseHttpBody, HTTPAPI_ERROR);
2666
2667 {
2668 STRICT_EXPECTED_CALL(HTTPAPI_CloseConnection(IGNORED_PTR_ARG))
2669 .IgnoreArgument(1);
2670
2671 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2672 .IgnoreArgument(1);
2673 whenShallHTTPAPI_CreateConnection_fail[0] = currentHTTPAPI_CreateConnection_call + 1;
2674 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
2675 }
2676
2677 {
2678 STRICT_EXPECTED_CALL(HTTPAPI_Deinit());
2679 STRICT_EXPECTED_CALL(HTTPAPI_Init());
2680 }
2681
2682 {
2683 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2684 .IgnoreArgument(1);
2685 whenShallHTTPAPI_CreateConnection_fail[1] = currentHTTPAPI_CreateConnection_call + 2;
2686 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
2687
2688 }
2689
2690 /*this is post final fail - sequence is reset to a clean start*/
2691 {
2692 STRICT_EXPECTED_CALL(HTTPAPI_Deinit());
2693 }
2694
2695 /// act
2696 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2697
2698 ///assert
2699 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_RECOVERYFAILED, result);
2700 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2701
2702 ///destroy
2703 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2704 HTTPAPIEX_Destroy(httpapiexhandle);
2705 }
2706
2707 /*Tests_SRS_HTTPAPIEX_02_029: [Otherwise, HTTAPIEX_ExecuteRequest shall return HTTPAPIEX_RECOVERYFAILED.] */
2708 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_TestCase_F3) /*refer to httpapiex_retry_mechanism.vsdx*/
2709 {
2710 /// arrange
2711 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
2712 HTTPAPIEX_RESULT result;
2713
2714 unsigned int httpStatusCode;
2715 unsigned int asGivenByHttpApi = 23;
2716 HTTP_HEADERS_HANDLE requestHttpHeaders;
2717 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
2718 HTTP_HEADERS_HANDLE responseHttpHeaders;
2719 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
2720 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2721 (void)HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2722 umock_c_reset_all_calls();
2723
2724 prepareHTTPAPIEX_ExecuteRequest(&asGivenByHttpApi, requestHttpHeaders, responseHttpHeaders, responseHttpBody, HTTPAPI_ERROR);
2725
2726 {
2727 STRICT_EXPECTED_CALL(HTTPAPI_CloseConnection(IGNORED_PTR_ARG))
2728 .IgnoreArgument(1);
2729
2730 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2731 .IgnoreArgument(1);
2732 whenShallHTTPAPI_CreateConnection_fail[0] = currentHTTPAPI_CreateConnection_call + 1;
2733 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
2734 }
2735
2736 {
2737 STRICT_EXPECTED_CALL(HTTPAPI_Deinit());
2738 STRICT_EXPECTED_CALL(HTTPAPI_Init());
2739 }
2740
2741 {
2742 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2743 .IgnoreArgument(1);
2744 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
2745 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
2746 .IgnoreArgument(1);
2747
2748 }
2749
2750 {
2751 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
2752 .IgnoreArgument(1);
2753 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
2754 .IgnoreArgument(1);
2755 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
2756 IGNORED_PTR_ARG,
2757 HTTPAPI_REQUEST_HEAD,
2758 TEST_RELATIVE_PATH,
2759 requestHttpHeaders,
2760 IGNORED_PTR_ARG,
2761 TEST_BUFFER_SIZE,
2762 IGNORED_PTR_ARG,
2763 responseHttpHeaders,
2764 responseHttpBody))
2765 .IgnoreArgument(1)
2766 .IgnoreArgument(4)
2767 .IgnoreArgument(5)
2768 .IgnoreArgument(7)
2769 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
2770 .CopyOutArgumentBuffer(7, &asGivenByHttpApi, sizeof(asGivenByHttpApi))
2771 .SetReturn(HTTPAPI_ERROR);
2772 ;
2773 }
2774
2775 /*this is post final fail - sequence is reset to a clean start*/
2776 {
2777 STRICT_EXPECTED_CALL(HTTPAPI_CloseConnection(IGNORED_PTR_ARG))
2778 .IgnoreArgument(1);
2779 STRICT_EXPECTED_CALL(HTTPAPI_Deinit());
2780 }
2781
2782 /// act
2783 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2784
2785 ///assert
2786 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_RECOVERYFAILED, result);
2787 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2788
2789 ///destroy
2790 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2791 HTTPAPIEX_Destroy(httpapiexhandle);
2792 }
2793
2794 /*Tests_SRS_HTTPAPIEX_02_029: [Otherwise, HTTAPIEX_ExecuteRequest shall return HTTPAPIEX_RECOVERYFAILED.] */
2795 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_TestCase_F4) /*refer to httpapiex_retry_mechanism.vsdx*/
2796 {
2797 /// arrange
2798 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
2799 HTTPAPIEX_RESULT result;
2800
2801 unsigned int httpStatusCode;
2802 unsigned int asGivenByHttpApi = 23;
2803 HTTP_HEADERS_HANDLE requestHttpHeaders;
2804 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
2805 HTTP_HEADERS_HANDLE responseHttpHeaders;
2806 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
2807 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2808 (void)HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2809 umock_c_reset_all_calls();
2810
2811 prepareHTTPAPIEX_ExecuteRequest(&asGivenByHttpApi, requestHttpHeaders, responseHttpHeaders, responseHttpBody, HTTPAPI_ERROR);
2812
2813 {
2814 STRICT_EXPECTED_CALL(HTTPAPI_CloseConnection(IGNORED_PTR_ARG))
2815 .IgnoreArgument(1);
2816
2817 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2818 .IgnoreArgument(1);
2819 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
2820 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
2821 .IgnoreArgument(1);
2822
2823 }
2824
2825 {
2826 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
2827 .IgnoreArgument(1);
2828 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
2829 .IgnoreArgument(1);
2830 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
2831 IGNORED_PTR_ARG,
2832 HTTPAPI_REQUEST_HEAD,
2833 TEST_RELATIVE_PATH,
2834 requestHttpHeaders,
2835 IGNORED_PTR_ARG,
2836 TEST_BUFFER_SIZE,
2837 IGNORED_PTR_ARG,
2838 responseHttpHeaders,
2839 responseHttpBody))
2840 .IgnoreArgument(1)
2841 .IgnoreArgument(4)
2842 .IgnoreArgument(5)
2843 .IgnoreArgument(7)
2844 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
2845 .CopyOutArgumentBuffer(7, &asGivenByHttpApi, sizeof(asGivenByHttpApi))
2846 .SetReturn(HTTPAPI_ERROR);
2847 ;
2848 }
2849
2850 {
2851 STRICT_EXPECTED_CALL(HTTPAPI_CloseConnection(IGNORED_PTR_ARG))
2852 .IgnoreArgument(1);
2853 STRICT_EXPECTED_CALL(HTTPAPI_Deinit());
2854
2855 whenShallHTTPAPI_Init_fail[0] = currentHTTPAPI_Init_call + 1;
2856 STRICT_EXPECTED_CALL(HTTPAPI_Init());
2857 }
2858
2859 /// act
2860 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2861
2862 ///assert
2863 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_RECOVERYFAILED, result);
2864 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2865
2866 ///destroy
2867 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2868 HTTPAPIEX_Destroy(httpapiexhandle);
2869 }
2870
2871 /*Tests_SRS_HTTPAPIEX_02_029: [Otherwise, HTTAPIEX_ExecuteRequest shall return HTTPAPIEX_RECOVERYFAILED.] */
2872 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_TestCase_F5) /*refer to httpapiex_retry_mechanism.vsdx*/
2873 {
2874 /// arrange
2875 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
2876 HTTPAPIEX_RESULT result;
2877
2878 unsigned int httpStatusCode;
2879 unsigned int asGivenByHttpApi = 23;
2880 HTTP_HEADERS_HANDLE requestHttpHeaders;
2881 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
2882 HTTP_HEADERS_HANDLE responseHttpHeaders;
2883 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
2884 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2885 (void)HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2886 umock_c_reset_all_calls();
2887
2888 prepareHTTPAPIEX_ExecuteRequest(&asGivenByHttpApi, requestHttpHeaders, responseHttpHeaders, responseHttpBody, HTTPAPI_ERROR);
2889
2890 {
2891 STRICT_EXPECTED_CALL(HTTPAPI_CloseConnection(IGNORED_PTR_ARG))
2892 .IgnoreArgument(1);
2893
2894 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2895 .IgnoreArgument(1);
2896 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
2897 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
2898 .IgnoreArgument(1);
2899
2900 }
2901
2902 {
2903 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
2904 .IgnoreArgument(1);
2905 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
2906 .IgnoreArgument(1);
2907 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
2908 IGNORED_PTR_ARG,
2909 HTTPAPI_REQUEST_HEAD,
2910 TEST_RELATIVE_PATH,
2911 requestHttpHeaders,
2912 IGNORED_PTR_ARG,
2913 TEST_BUFFER_SIZE,
2914 IGNORED_PTR_ARG,
2915 responseHttpHeaders,
2916 responseHttpBody))
2917 .IgnoreArgument(1)
2918 .IgnoreArgument(4)
2919 .IgnoreArgument(5)
2920 .IgnoreArgument(7)
2921 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
2922 .CopyOutArgumentBuffer(7, &asGivenByHttpApi, sizeof(asGivenByHttpApi))
2923 .SetReturn(HTTPAPI_ERROR);
2924 ;
2925 }
2926
2927 {
2928 STRICT_EXPECTED_CALL(HTTPAPI_CloseConnection(IGNORED_PTR_ARG))
2929 .IgnoreArgument(1);
2930 STRICT_EXPECTED_CALL(HTTPAPI_Deinit());
2931 STRICT_EXPECTED_CALL(HTTPAPI_Init());
2932 }
2933
2934 {
2935 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2936 .IgnoreArgument(1);
2937 whenShallHTTPAPI_CreateConnection_fail[1] = currentHTTPAPI_CreateConnection_call + 2;
2938 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
2939 }
2940
2941 {
2942 STRICT_EXPECTED_CALL(HTTPAPI_Deinit());
2943 }
2944
2945 /// act
2946 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2947
2948 ///assert
2949 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_RECOVERYFAILED, result);
2950 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
2951
2952 ///destroy
2953 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2954 HTTPAPIEX_Destroy(httpapiexhandle);
2955 }
2956
2957 /*Tests_SRS_HTTPAPIEX_02_029: [Otherwise, HTTAPIEX_ExecuteRequest shall return HTTPAPIEX_RECOVERYFAILED.] */
2958 TEST_FUNCTION(HTTPAPIEX_ExecuteRequest_TestCase_F6) /*refer to httpapiex_retry_mechanism.vsdx*/
2959 {
2960 /// arrange
2961 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
2962 HTTPAPIEX_RESULT result;
2963
2964 unsigned int httpStatusCode;
2965 unsigned int asGivenByHttpApi = 23;
2966 HTTP_HEADERS_HANDLE requestHttpHeaders;
2967 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
2968 HTTP_HEADERS_HANDLE responseHttpHeaders;
2969 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
2970 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
2971 (void)HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
2972 umock_c_reset_all_calls();
2973
2974 prepareHTTPAPIEX_ExecuteRequest(&asGivenByHttpApi, requestHttpHeaders, responseHttpHeaders, responseHttpBody, HTTPAPI_ERROR);
2975
2976 {
2977 STRICT_EXPECTED_CALL(HTTPAPI_CloseConnection(IGNORED_PTR_ARG))
2978 .IgnoreArgument(1);
2979
2980 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
2981 .IgnoreArgument(1);
2982 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
2983 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
2984 .IgnoreArgument(1);
2985
2986 }
2987
2988 {
2989 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
2990 .IgnoreArgument(1);
2991 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
2992 .IgnoreArgument(1);
2993 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
2994 IGNORED_PTR_ARG,
2995 HTTPAPI_REQUEST_HEAD,
2996 TEST_RELATIVE_PATH,
2997 requestHttpHeaders,
2998 IGNORED_PTR_ARG,
2999 TEST_BUFFER_SIZE,
3000 IGNORED_PTR_ARG,
3001 responseHttpHeaders,
3002 responseHttpBody))
3003 .IgnoreArgument(1)
3004 .IgnoreArgument(4)
3005 .IgnoreArgument(5)
3006 .IgnoreArgument(7)
3007 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
3008 .CopyOutArgumentBuffer(7, &asGivenByHttpApi, sizeof(asGivenByHttpApi))
3009 .SetReturn(HTTPAPI_ERROR);
3010 ;
3011 }
3012
3013 {
3014 STRICT_EXPECTED_CALL(HTTPAPI_CloseConnection(IGNORED_PTR_ARG))
3015 .IgnoreArgument(1);
3016 STRICT_EXPECTED_CALL(HTTPAPI_Deinit());
3017 STRICT_EXPECTED_CALL(HTTPAPI_Init());
3018 }
3019
3020 {
3021 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
3022 .IgnoreArgument(1);
3023 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
3024 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
3025 .IgnoreArgument(1);
3026
3027 }
3028
3029 {
3030 STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG))
3031 .IgnoreArgument(1);
3032 STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG))
3033 .IgnoreArgument(1);
3034 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
3035 IGNORED_PTR_ARG,
3036 HTTPAPI_REQUEST_HEAD,
3037 TEST_RELATIVE_PATH,
3038 requestHttpHeaders,
3039 IGNORED_PTR_ARG,
3040 TEST_BUFFER_SIZE,
3041 IGNORED_PTR_ARG,
3042 responseHttpHeaders,
3043 responseHttpBody))
3044 .IgnoreArgument(1)
3045 .IgnoreArgument(4)
3046 .IgnoreArgument(5)
3047 .IgnoreArgument(7)
3048 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
3049 .CopyOutArgumentBuffer(7, &asGivenByHttpApi, sizeof(asGivenByHttpApi))
3050 .SetReturn(HTTPAPI_ERROR);
3051 ;
3052 }
3053
3054 {
3055 STRICT_EXPECTED_CALL(HTTPAPI_CloseConnection(IGNORED_PTR_ARG))
3056 .IgnoreArgument(1);
3057 STRICT_EXPECTED_CALL(HTTPAPI_Deinit());
3058 }
3059
3060 /// act
3061 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
3062
3063 ///assert
3064 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_RECOVERYFAILED, result);
3065 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3066
3067 ///destroy
3068 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
3069 HTTPAPIEX_Destroy(httpapiexhandle);
3070 }
3071
3072 /*Tests_SRS_HTTPAPIEX_02_032: [If parameter handle is NULL then HTTPAPIEX_SetOption shall return HTTPAPIEX_INVALID_ARG.] */
3073 TEST_FUNCTION(HTTPAPIEX_SetOption_fails_with_NULL_handle)
3074 {
3075 /// arrange
3076
3077 /// act
3078 HTTPAPIEX_RESULT result = HTTPAPIEX_SetOption(NULL, "someOption", (void*)42);
3079
3080 ///assert
3081 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_INVALID_ARG, result);
3082 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3083
3084 ///destroy
3085 }
3086
3087 /*Tests_SRS_HTTPAPIEX_02_033: [If parameter optionName is NULL then HTTPAPIEX_SetOption shall return HTTPAPIEX_INVALID_ARG.] */
3088 TEST_FUNCTION(HTTPAPIEX_SetOption_fails_with_NULL_optionName_fails)
3089 {
3090 /// arrange
3091 HTTPAPIEX_RESULT result;
3092 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
3093 umock_c_reset_all_calls();
3094
3095 /// act
3096 result = HTTPAPIEX_SetOption(httpapiexhandle, NULL, (void*)42);
3097
3098 ///assert
3099 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_INVALID_ARG, result);
3100 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3101
3102 ///destroy
3103 HTTPAPIEX_Destroy(httpapiexhandle);
3104 }
3105
3106 /*Tests_SRS_HTTPAPIEX_02_034: [If parameter value is NULL then HTTPAPIEX_SetOption shall return HTTPAPIEX_INVALID_ARG.] */
3107 TEST_FUNCTION(HTTPAPIEX_SetOption_fails_with_NULL_value_fails)
3108 {
3109 /// arrange
3110 HTTPAPIEX_RESULT result;
3111 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
3112 umock_c_reset_all_calls();
3113
3114 /// act
3115 result = HTTPAPIEX_SetOption(httpapiexhandle, "someOption", NULL);
3116
3117 ///assert
3118 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_INVALID_ARG, result);
3119 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3120
3121 ///destroy
3122 HTTPAPIEX_Destroy(httpapiexhandle);
3123 }
3124
3125 /*Tests_SRS_HTTPAPIEX_02_037: [HTTPAPIEX_SetOption shall attempt to save the value of the option by calling HTTPAPI_CloneOption passing optionName and value, irrespective of the existence of a HTTPAPI_HANDLE] */
3126 /*Tests_SRS_HTTPAPIEX_02_039: [If HTTPAPI_CloneOption returns HTTPAPI_OK then HTTPAPIEX_SetOption shall create or update the pair optionName/value.]*/
3127 TEST_FUNCTION(HTTPAPIEX_SetOption_happy_path_without_httpapi_handle_succeeds)
3128 {
3129 /// arrange
3130 HTTPAPIEX_RESULT result;
3131 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
3132 umock_c_reset_all_calls();
3133
3134 EXPECTED_CALL(HTTPAPI_CloneOption("someOption", "333", IGNORED_PTR_ARG)); /*this asks lower HTTPAPI to create a clone of the option*/
3135
3136 EXPECTED_CALL(VECTOR_find_if(IGNORED_PTR_ARG, IGNORED_PTR_ARG, "someOption")); /*this is looking for optionName*/
3137
3138 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "someOption"))
3139 .IgnoreArgument(1); /*this is creating a clone of the optionName*/
3140
3141 STRICT_EXPECTED_CALL(VECTOR_push_back(IGNORED_PTR_ARG, IGNORED_PTR_ARG, 1)) /*this is adding the optionName, value*/
3142 .IgnoreArgument(1)
3143 .IgnoreArgument(2);
3144
3145 /// act
3146 result = HTTPAPIEX_SetOption(httpapiexhandle, "someOption", "333");
3147
3148 ///assert
3149 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
3150 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3151
3152 ///destroy
3153 HTTPAPIEX_Destroy(httpapiexhandle);
3154 }
3155
3156 /*Tests_SRS_HTTPAPIEX_02_037: [HTTPAPIEX_SetOption shall attempt to save the value of the option by calling HTTPAPI_CloneOption passing optionName and value, irrespective of the existence of a HTTPAPI_HANDLE] */
3157 /*Tests_SRS_HTTPAPIEX_02_039: [If HTTPAPI_CloneOption returns HTTPAPI_OK then HTTPAPIEX_SetOption shall create or update the pair optionName/value.]*/
3158 TEST_FUNCTION(HTTPAPIEX_SetOption_happy_path_without_httpapi_handle_can_save_2_options_succeeds)
3159 {
3160 /// arrange
3161 HTTPAPIEX_RESULT result1;
3162 HTTPAPIEX_RESULT result2;
3163 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
3164 umock_c_reset_all_calls();
3165
3166 EXPECTED_CALL(HTTPAPI_CloneOption("someOption1", (void*)"3", IGNORED_PTR_ARG)); /*this asks lower HTTPAPI to create a clone of the option*/
3167
3168 EXPECTED_CALL(VECTOR_find_if(IGNORED_PTR_ARG, IGNORED_PTR_ARG, "someOption1")); /*this is looking for the option to device between update / create*/
3169
3170 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "someOption1"))
3171 .IgnoreArgument(1); /*this is creating a clone of the optionName*/
3172
3173 STRICT_EXPECTED_CALL(VECTOR_push_back(IGNORED_PTR_ARG, IGNORED_PTR_ARG, 1)) /*this is increasing the array of options by 1*/
3174 .IgnoreArgument(1)
3175 .IgnoreArgument(2);
3176
3177 EXPECTED_CALL(HTTPAPI_CloneOption("someOption2", (void*)"33", IGNORED_PTR_ARG)); /*this asks lower HTTPAPI to create a clone of the option*/
3178
3179 EXPECTED_CALL(VECTOR_find_if(IGNORED_PTR_ARG, IGNORED_PTR_ARG, "someOption2")); /*this is looking for the option to device between update / create*/
3180
3181 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "someOption2"))
3182 .IgnoreArgument(1); /*this is creating a clone of the optionName*/
3183
3184 STRICT_EXPECTED_CALL(VECTOR_push_back(IGNORED_PTR_ARG, IGNORED_PTR_ARG, 1)) /*this is increasing the array of options by 1*/
3185 .IgnoreArgument(1)
3186 .IgnoreArgument(2);
3187
3188 /// act
3189 result1 = HTTPAPIEX_SetOption(httpapiexhandle, "someOption1", (void*)"3");
3190 result2 = HTTPAPIEX_SetOption(httpapiexhandle, "someOption2", (void*)"33");
3191
3192 ///assert
3193 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result1);
3194 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result2);
3195 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3196
3197 ///destroy
3198 HTTPAPIEX_Destroy(httpapiexhandle);
3199 }
3200
3201 /*Tests_SRS_HTTPAPIEX_02_035: [HTTPAPIEX_ExecuteRequest shall pass all the saved options (see HTTPAPIEX_SetOption) to the newly create HTTPAPI_HANDLE in step 2 by calling HTTPAPI_SetOption.]*/
3202 TEST_FUNCTION(HTTPAPIEX_SetOption_passes_saved_options_to_httpapi_succeeds)
3203 {
3204 /// arrange
3205 HTTPAPIEX_RESULT result;
3206 HTTPAPIEX_HANDLE httpapiexhandle;
3207 size_t requestHttpBodyLength;
3208 const unsigned char* requestHttpBodyContent;
3209 unsigned int httpStatusCode;
3210 HTTP_HEADERS_HANDLE requestHttpHeaders;
3211 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
3212 HTTP_HEADERS_HANDLE responseHttpHeaders;
3213 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
3214 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
3215
3216 httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
3217 (void)HTTPAPIEX_SetOption(httpapiexhandle, "someOption1", (void*)"3");
3218 (void)HTTPAPIEX_SetOption(httpapiexhandle, "someOption2", (void*)"33");
3219 umock_c_reset_all_calls();
3220
3221 setupAllCallBeforeHTTPsequence();
3222 STRICT_EXPECTED_CALL(HTTPAPI_Init());
3223
3224 /*this is getting the hostname for the HTTAPI_connect call)*/
3225 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
3226 .IgnoreArgument(1);
3227 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
3228 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
3229 .IgnoreArgument(1);
3230
3231 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 0))
3232 .IgnoreArgument(1);
3233 STRICT_EXPECTED_CALL(HTTPAPI_SetOption(IGNORED_PTR_ARG, "someOption1", (void*)"3"))
3234 .IgnoreArgument(1)
3235 .IgnoreArgument(3);
3236
3237 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 1))
3238 .IgnoreArgument(1);
3239 STRICT_EXPECTED_CALL(HTTPAPI_SetOption(IGNORED_PTR_ARG, "someOption2", (void*)"33"))
3240 .IgnoreArgument(1)
3241 .IgnoreArgument(3);
3242
3243 STRICT_EXPECTED_CALL(BUFFER_length(requestHttpBody))
3244 .SetReturn(TEST_BUFFER_SIZE);
3245 requestHttpBodyLength = TEST_BUFFER_SIZE;
3246
3247 STRICT_EXPECTED_CALL(BUFFER_u_char(requestHttpBody))
3248 .SetReturn(TEST_BUFFER);
3249 requestHttpBodyContent = TEST_BUFFER;
3250
3251 /*this is getting the buffer content and buffer length to pass to httpapi_executerequest*/
3252 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
3253 IGNORED_PTR_ARG,
3254 HTTPAPI_REQUEST_HEAD,
3255 TEST_RELATIVE_PATH,
3256 requestHttpHeaders,
3257 requestHttpBodyContent,
3258 requestHttpBodyLength,
3259 IGNORED_PTR_ARG,
3260 responseHttpHeaders,
3261 responseHttpBody))
3262 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
3263 .IgnoreArgument(1)
3264 .IgnoreArgument(7)
3265 ;
3266
3267 /// act
3268 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
3269
3270 ///assert
3271 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
3272 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3273
3274 ///destroy
3275 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
3276 HTTPAPIEX_Destroy(httpapiexhandle);
3277 }
3278
3279 /*Tests_SRS_HTTPAPIEX_02_036: [If setting the option fails, then the failure shall be ignored.] */
3280 TEST_FUNCTION(HTTPAPIEX_SetOption_passes_saved_options_to_httpapi_ignores_errors_succeeds)
3281 {
3282 /// arrange
3283 unsigned int httpStatusCode;
3284 size_t requestHttpBodyLength;
3285 const unsigned char* requestHttpBodyContent;
3286 HTTPAPIEX_RESULT result;
3287 HTTPAPIEX_HANDLE httpapiexhandle;
3288 HTTP_HEADERS_HANDLE requestHttpHeaders;
3289 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
3290 HTTP_HEADERS_HANDLE responseHttpHeaders;
3291 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
3292 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
3293
3294 httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
3295 (void)HTTPAPIEX_SetOption(httpapiexhandle, "someOption1", (void*)"3");
3296 (void)HTTPAPIEX_SetOption(httpapiexhandle, "someOption2", (void*)"33");
3297 umock_c_reset_all_calls();
3298
3299 setupAllCallBeforeHTTPsequence();
3300 STRICT_EXPECTED_CALL(HTTPAPI_Init());
3301
3302 /*this is getting the hostname for the HTTAPI_connect call)*/
3303 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG))
3304 .IgnoreArgument(1);
3305 STRICT_EXPECTED_CALL(HTTPAPI_CreateConnection(TEST_HOSTNAME));
3306 STRICT_EXPECTED_CALL(VECTOR_size(IGNORED_PTR_ARG)) /*this is passing the options*/ /*there are none saved in the regular sequences*/
3307 .IgnoreArgument(1);
3308
3309 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 0))
3310 .IgnoreArgument(1);
3311 STRICT_EXPECTED_CALL(HTTPAPI_SetOption(IGNORED_PTR_ARG, "someOption1", (void*)"3"))
3312 .IgnoreArgument(1)
3313 .IgnoreArgument(3)
3314 .SetReturn(HTTPAPI_ERROR);
3315
3316 STRICT_EXPECTED_CALL(VECTOR_element(IGNORED_PTR_ARG, 1))
3317 .IgnoreArgument(1);
3318 STRICT_EXPECTED_CALL(HTTPAPI_SetOption(IGNORED_PTR_ARG, "someOption2", (void*)"33"))
3319 .IgnoreArgument(1)
3320 .IgnoreArgument(3)
3321 .SetReturn(HTTPAPI_ERROR);
3322
3323 STRICT_EXPECTED_CALL(BUFFER_length(requestHttpBody))
3324 .SetReturn(TEST_BUFFER_SIZE);
3325 requestHttpBodyLength = TEST_BUFFER_SIZE;
3326
3327 STRICT_EXPECTED_CALL(BUFFER_u_char(requestHttpBody))
3328 .SetReturn(TEST_BUFFER);
3329 requestHttpBodyContent = TEST_BUFFER;
3330
3331 /*this is getting the buffer content and buffer length to pass to httpapi_executerequest*/
3332 STRICT_EXPECTED_CALL(HTTPAPI_ExecuteRequest(
3333 IGNORED_PTR_ARG,
3334 HTTPAPI_REQUEST_HEAD,
3335 TEST_RELATIVE_PATH,
3336 requestHttpHeaders,
3337 requestHttpBodyContent,
3338 requestHttpBodyLength,
3339 IGNORED_PTR_ARG,
3340 responseHttpHeaders,
3341 responseHttpBody))
3342 .ValidateArgumentBuffer(5, TEST_BUFFER, TEST_BUFFER_SIZE)
3343 .IgnoreArgument(1)
3344 .IgnoreArgument(7)
3345 ;
3346
3347 /// act
3348 result = HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
3349
3350 ///assert
3351 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
3352 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3353
3354 ///destroy
3355 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
3356 HTTPAPIEX_Destroy(httpapiexhandle);
3357 }
3358
3359 /*Tests_SRS_HTTPAPIEX_02_041: [If creating or updating the pair optionName/value fails then shall return HTTPAPIEX_ERROR.] */
3360 TEST_FUNCTION(HTTPAPIEX_SetOption_fails_when_VECTOR_push_back_fails)
3361 {
3362 /// arrange
3363 HTTPAPIEX_RESULT result;
3364 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
3365 umock_c_reset_all_calls();
3366
3367 EXPECTED_CALL(HTTPAPI_CloneOption("someOption2", (void*)"33", IGNORED_PTR_ARG)); /*this asks lower HTTPAPI to create a clone of the option*/
3368
3369 EXPECTED_CALL(VECTOR_find_if(IGNORED_PTR_ARG, IGNORED_PTR_ARG, "someOption2")); /*this is looking for the option to device between update / create*/
3370
3371 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "someOption2"))
3372 .IgnoreArgument(1); /*this is creating a clone of the optionName*/
3373
3374 STRICT_EXPECTED_CALL(VECTOR_push_back(IGNORED_PTR_ARG, IGNORED_PTR_ARG, 1))
3375 .IgnoreArgument(1)
3376 .IgnoreArgument(2)
3377 .SetReturn(1);
3378
3379 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG))
3380 .IgnoreArgument(1);
3381 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*this is freeing the clone created by HTTPAPI_CloneOption*/
3382 .IgnoreArgument(1);
3383
3384 /// act
3385 result = HTTPAPIEX_SetOption(httpapiexhandle, "someOption2", (void*)"33");
3386
3387 ///assert
3388 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_ERROR, result);
3389 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3390
3391 ///destroy
3392 HTTPAPIEX_Destroy(httpapiexhandle);
3393 }
3394
3395 /*Tests_SRS_HTTPAPIEX_02_041: [If creating or updating the pair optionName/value fails then shall return HTTPAPIEX_ERROR.] */
3396 TEST_FUNCTION(HTTPAPIEX_SetOption_fails_when_gballoc_fails_1)
3397 {
3398 /// arrange
3399 HTTPAPIEX_RESULT result;
3400 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
3401 umock_c_reset_all_calls();
3402
3403 EXPECTED_CALL(HTTPAPI_CloneOption("someOption2", (void*)"33", IGNORED_PTR_ARG)); /*this asks lower HTTPAPI to create a clone of the option*/
3404
3405 EXPECTED_CALL(VECTOR_find_if(IGNORED_PTR_ARG, IGNORED_PTR_ARG, "someOption2")); /*this is looking for the option to device between update / create*/
3406
3407 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "someOption2"))
3408 .IgnoreArgument(1).SetReturn(1); /*this is creating a clone of the optionName*/
3409
3410 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)) /*this is freeing the clone created by HTTPAPI_CloneOption*/
3411 .IgnoreArgument(1);
3412
3413 /// act
3414 result = HTTPAPIEX_SetOption(httpapiexhandle, "someOption2", (void*)"33");
3415
3416 ///assert
3417 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_ERROR, result);
3418 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3419
3420 ///destroy
3421 HTTPAPIEX_Destroy(httpapiexhandle);
3422 }
3423
3424 /*Tests_SRS_HTTPAPIEX_02_041: [If creating or updating the pair optionName/value fails then shall return HTTPAPIEX_ERROR.] */
3425 /*Tests_SRS_HTTPAPIEX_02_040: [For all other return values of HTTPAPI_SetOption, HTTPIAPIEX_SetOption shall return HTTPAPIEX_ERROR.] */
3426 TEST_FUNCTION(HTTPAPIEX_SetOption_fails_when_HTTPAPI_SaveOption_fails_3)
3427 {
3428 /// arrange
3429 HTTPAPIEX_RESULT result;
3430 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
3431 umock_c_reset_all_calls();
3432
3433 whenShallHTTPAPI_SaveOption_fail = currentHTTPAPI_SaveOption_call + 1;
3434 EXPECTED_CALL(HTTPAPI_CloneOption("someOption2", (void*)"33", IGNORED_PTR_ARG)) /*this asks lower HTTPAPI to create a clone of the option*/
3435 .SetReturn(HTTPAPI_ALREADY_INIT); /*some random error code*/
3436
3437 /// act
3438 result = HTTPAPIEX_SetOption(httpapiexhandle, "someOption2", (void*)"33");
3439
3440 ///assert
3441 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_ERROR, result);
3442 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3443
3444 ///destroy
3445 HTTPAPIEX_Destroy(httpapiexhandle);
3446 }
3447
3448 /*Tests_SRS_HTTPAPIEX_02_038: [If HTTPAPI_CloneOption returns HTTPAPI_INVALID_ARG then HTTPAPIEX shall return HTTPAPIEX_INVALID_ARG.]*/
3449 TEST_FUNCTION(HTTPAPIEX_SetOption_fails_when_HTTPAPI_SaveOption_fails_4)
3450 {
3451 /// arrange
3452 HTTPAPIEX_RESULT result;
3453 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
3454 umock_c_reset_all_calls();
3455
3456 whenShallHTTPAPI_SaveOption_fail = currentHTTPAPI_SaveOption_call + 1;
3457 EXPECTED_CALL(HTTPAPI_CloneOption("someOption2", (void*)"33", IGNORED_PTR_ARG)) /*this asks lower HTTPAPI to create a clone of the option*/
3458 .SetReturn(HTTPAPI_INVALID_ARG);
3459
3460 /// act
3461 result = HTTPAPIEX_SetOption(httpapiexhandle, "someOption2", (void*)"33");
3462
3463 ///assert
3464 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_INVALID_ARG, result);
3465 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3466
3467 ///destroy
3468 HTTPAPIEX_Destroy(httpapiexhandle);
3469 }
3470
3471 /*Tests_SRS_HTTPAPIEX_02_031: [If HTTPAPI_HANDLE exists then HTTPAPIEX_SetOption shall call HTTPAPI_SetOption passing the same optionName and value and shall return a value conforming to the below table:] */
3472 TEST_FUNCTION(HTTPAPIEX_SetOption_passes_saved_options_to_existing_httpapi_handle_succeeds)
3473 {
3474 /// arrange
3475 HTTPAPIEX_RESULT result;
3476 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
3477
3478 unsigned int httpStatusCode;
3479 HTTP_HEADERS_HANDLE requestHttpHeaders;
3480 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
3481 HTTP_HEADERS_HANDLE responseHttpHeaders;
3482 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
3483 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
3484
3485 setupAllCallBeforeHTTPsequence();
3486 setupAllCallForHTTPsequence(TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, responseHttpHeaders, responseHttpBody);
3487 (void)HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
3488 umock_c_reset_all_calls();
3489
3490 EXPECTED_CALL(HTTPAPI_CloneOption("someOption", "3", IGNORED_PTR_ARG)); /*this asks lower HTTPAPI to create a clone of the option*/
3491
3492 EXPECTED_CALL(VECTOR_find_if(IGNORED_PTR_ARG, IGNORED_PTR_ARG, "someOption")); /*this is looking for the option to device between update / create*/
3493
3494 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "someOption"))
3495 .IgnoreArgument(1); /*this is creating a clone of the optionName*/
3496
3497 STRICT_EXPECTED_CALL(VECTOR_push_back(IGNORED_PTR_ARG, IGNORED_PTR_ARG, 1)) /*this is increasing the array of options by 1*/
3498 .IgnoreArgument(1)
3499 .IgnoreArgument(2);
3500
3501 EXPECTED_CALL(HTTPAPI_SetOption(IGNORED_PTR_ARG, "someOption", "3"));
3502
3503 /// act
3504 result = HTTPAPIEX_SetOption(httpapiexhandle, "someOption", "3");
3505
3506 ///assert
3507 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
3508 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3509
3510 ///destroy
3511 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
3512 HTTPAPIEX_Destroy(httpapiexhandle);
3513 }
3514
3515 /*Tests_SRS_HTTPAPIEX_02_031: [If HTTPAPI_HANDLE exists then HTTPAPIEX_SetOption shall call HTTPAPI_SetOption passing the same optionName and value and shall return a value conforming to the below table:] */
3516 TEST_FUNCTION(HTTPAPIEX_SetOption_passes_saved_options_to_existing_httpapi_handle_fails_1)
3517 {
3518 /// arrange
3519 HTTPAPIEX_RESULT result;
3520 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
3521
3522 unsigned int httpStatusCode;
3523 HTTP_HEADERS_HANDLE requestHttpHeaders;
3524 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
3525 HTTP_HEADERS_HANDLE responseHttpHeaders;
3526 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
3527 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
3528
3529 setupAllCallBeforeHTTPsequence();
3530 setupAllCallForHTTPsequence(TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, responseHttpHeaders, responseHttpBody);
3531 (void)HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
3532 umock_c_reset_all_calls();
3533
3534 EXPECTED_CALL(HTTPAPI_CloneOption("someOption", "3", IGNORED_PTR_ARG)); /*this asks lower HTTPAPI to create a clone of the option*/
3535
3536 EXPECTED_CALL(VECTOR_find_if(IGNORED_PTR_ARG, IGNORED_PTR_ARG, "someOption")); /*this is looking for the option to device between update / create*/
3537
3538 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "someOption"))
3539 .IgnoreArgument(1); /*this is creating a clone of the optionName*/
3540
3541 STRICT_EXPECTED_CALL(VECTOR_push_back(IGNORED_PTR_ARG, IGNORED_PTR_ARG, 1)) /*this is increasing the array of options by 1*/
3542 .IgnoreArgument(1)
3543 .IgnoreArgument(2);
3544
3545 EXPECTED_CALL(HTTPAPI_SetOption(IGNORED_PTR_ARG, "someOption", "3"))
3546 .SetReturn(HTTPAPI_INVALID_ARG);
3547
3548 /// act
3549 result = HTTPAPIEX_SetOption(httpapiexhandle, "someOption", "3");
3550
3551 ///assert
3552 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_INVALID_ARG, result);
3553 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3554
3555 ///destroy
3556 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
3557 HTTPAPIEX_Destroy(httpapiexhandle);
3558 }
3559
3560 /*Tests_SRS_HTTPAPIEX_02_031: [If HTTPAPI_HANDLE exists then HTTPAPIEX_SetOption shall call HTTPAPI_SetOption passing the same optionName and value and shall return a value conforming to the below table:] */
3561 TEST_FUNCTION(HTTPAPIEX_SetOption_passes_saved_options_to_existing_httpapi_handle_fails_2)
3562 {
3563 /// arrange
3564 HTTPAPIEX_RESULT result;
3565 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
3566
3567 unsigned int httpStatusCode;
3568 HTTP_HEADERS_HANDLE requestHttpHeaders;
3569 BUFFER_HANDLE requestHttpBody = TEST_BUFFER_REQ_BODY;
3570 HTTP_HEADERS_HANDLE responseHttpHeaders;
3571 BUFFER_HANDLE responseHttpBody = TEST_BUFFER_RESP_BODY;
3572 createHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
3573
3574 setupAllCallBeforeHTTPsequence();
3575 setupAllCallForHTTPsequence(TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, responseHttpHeaders, responseHttpBody);
3576 (void)HTTPAPIEX_ExecuteRequest(httpapiexhandle, HTTPAPI_REQUEST_HEAD, TEST_RELATIVE_PATH, requestHttpHeaders, requestHttpBody, &httpStatusCode, responseHttpHeaders, responseHttpBody);
3577 umock_c_reset_all_calls();
3578
3579 EXPECTED_CALL(HTTPAPI_CloneOption("someOption", "3", IGNORED_PTR_ARG)); /*this asks lower HTTPAPI to create a clone of the option*/
3580
3581 EXPECTED_CALL(VECTOR_find_if(IGNORED_PTR_ARG, IGNORED_PTR_ARG, "someOption")); /*this is looking for the option to device between update / create*/
3582
3583 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, "someOption"))
3584 .IgnoreArgument(1); /*this is creating a clone of the optionName*/
3585
3586 STRICT_EXPECTED_CALL(VECTOR_push_back(IGNORED_PTR_ARG, IGNORED_PTR_ARG, 1)) /*this is increasing the array of options by 1*/
3587 .IgnoreArgument(1)
3588 .IgnoreArgument(2);
3589
3590 EXPECTED_CALL(HTTPAPI_SetOption(IGNORED_PTR_ARG, "someOption", "3"))
3591 .SetReturn(HTTPAPI_ALLOC_FAILED);
3592
3593 /// act
3594 result = HTTPAPIEX_SetOption(httpapiexhandle, "someOption", "3");
3595
3596 ///assert
3597 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_ERROR, result);
3598 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3599
3600 ///destroy
3601 destroyHttpObjects(&requestHttpHeaders, &responseHttpHeaders);
3602 HTTPAPIEX_Destroy(httpapiexhandle);
3603 }
3604
3605 /*Tests_SRS_HTTPAPIEX_02_039: [If HTTPAPI_CloneOption returns HTTPAPI_OK then HTTPAPIEX_SetOption shall create or update the pair optionName/value.]*/
3606 TEST_FUNCTION(HTTPAPIEX_SetOption_happy_path_on_update_option_value_succeeds)
3607 {
3608 HTTPAPIEX_RESULT result;
3609 const char* OPTION_NAME = "someOption";
3610
3611 /// arrange
3612 HTTPAPIEX_HANDLE httpapiexhandle = HTTPAPIEX_Create(TEST_HOSTNAME);
3613 HTTPAPIEX_SetOption(httpapiexhandle, OPTION_NAME, "333");
3614 umock_c_reset_all_calls();
3615
3616 EXPECTED_CALL(HTTPAPI_CloneOption(OPTION_NAME, "4", IGNORED_PTR_ARG)); /*this asks lower HTTPAPI to create a clone of the option*/
3617
3618 EXPECTED_CALL(VECTOR_find_if(IGNORED_PTR_ARG, IGNORED_PTR_ARG, OPTION_NAME)); /*this is looking for the option to device between update / create*/
3619
3620 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)); /*this is free-ing the previos value*/
3621
3622 /// act
3623 result = HTTPAPIEX_SetOption(httpapiexhandle, OPTION_NAME, "4");
3624
3625 ///assert
3626 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, HTTPAPIEX_OK, result);
3627 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3628
3629 ///destroy
3630 HTTPAPIEX_Destroy(httpapiexhandle);
3631 }
3632
3633 /*Tests_SRS_HTTPAPIEX_02_043: [If parameter handle is NULL then HTTPAPIEX_Destroy shall take no action.] */
3634 TEST_FUNCTION(HTTPAPIEX_Destroy_with_NULL_argument_does_nothing)
3635 {
3636 /// arrange
3637 /// act
3638 HTTPAPIEX_Destroy(NULL);
3639
3640 ///assert
3641 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
3642
3643 ///destroy
3644 }
3645
3646 END_TEST_SUITE(httpapiex_unittests)