1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16
17 #include <cstring>
18 #include <iostream>
19 #include <vector>
20 #include <string>
21 #include "gtest/gtest.h"
22
23 #include "net_http.h"
24 #include "netstack_hash_map.h"
25 #include "netstack_log.h"
26 #include "net_http_inner_types.h"
27 #include "http_client_request.h"
28 #include "http_client.h"
29 #include "http_client_constant.h"
30 #include "net_http_type.h"
31
32 using namespace OHOS::NetStack::HttpClient;
33
34 class NetHttpTest : public testing::Test {
35 public:
SetUpTestCase()36 static void SetUpTestCase() {}
37
TearDownTestCase()38 static void TearDownTestCase() {}
39
SetUp()40 virtual void SetUp() {}
41
TearDown()42 virtual void TearDown() {}
43 };
44
45 namespace {
46 using namespace std;
47 using namespace testing::ext;
48
MyCallbackFunction()49 static void MyCallbackFunction()
50 {
51 NETSTACK_LOGI("MyCallbackFunction function called!");
52 }
53
TestResponseCallback(struct Http_Response * response,uint32_t errCode)54 static void TestResponseCallback(struct Http_Response *response, uint32_t errCode)
55 {
56 NETSTACK_LOGI("TestResponseCallback function called!");
57 }
58
TestDataReceiveCallback(const char * data,size_t length)59 static void TestDataReceiveCallback(const char *data, size_t length)
60 {
61 NETSTACK_LOGI("testDataReceiveCallback function called!");
62 return;
63 }
64
testHeaderReceiveCallback(Http_Headers * headers)65 static void testHeaderReceiveCallback(Http_Headers *headers)
66 {
67 NETSTACK_LOGI("testHeaderReceiveCallback function called!");
68 }
69
70 HWTEST_F(NetHttpTest, CreateHeaders001, TestSize.Level1)
71 {
72 Http_Headers *header = OH_Http_CreateHeaders();
73 EXPECT_TRUE(header != nullptr);
74 OH_Http_DestroyHeaders(&header);
75 }
76
77 HWTEST_F(NetHttpTest, DestroyHeaders001, TestSize.Level1)
78 {
79 Http_Headers *header = OH_Http_CreateHeaders();
80 EXPECT_TRUE(header != nullptr);
81 EXPECT_EQ(OH_Http_SetHeaderValue(header, "key", "value"), OH_HTTP_RESULT_OK);
82 OH_Http_DestroyHeaders(&header);
83 }
84
85 HWTEST_F(NetHttpTest, DestroyHeaders002, TestSize.Level1)
86 {
87 Http_Headers *header = nullptr;
88 OH_Http_DestroyHeaders(&header);
89
90 OH_Http_DestroyHeaders(nullptr);
91 }
92
93 HWTEST_F(NetHttpTest, ToLowerCase001, TestSize.Level1)
94 {
95 Http_Headers *header = OH_Http_CreateHeaders();
96 EXPECT_TRUE(header != nullptr);
97
98 OH_Http_SetHeaderValue(header, "TEST", "value");
99 OH_Http_DestroyHeaders(&header);
100 }
101
102 HWTEST_F(NetHttpTest, SetHeaderValue001, TestSize.Level1)
103 {
104 uint32_t ret = OH_Http_SetHeaderValue(nullptr, "key", "test");
105 EXPECT_EQ(ret, OH_HTTP_PARAMETER_ERROR);
106
107 Http_Headers *header = OH_Http_CreateHeaders();
108 EXPECT_TRUE(header != nullptr);
109 ret = OH_Http_SetHeaderValue(header, nullptr, "test");
110 EXPECT_EQ(ret, OH_HTTP_PARAMETER_ERROR);
111
112 ret = OH_Http_SetHeaderValue(header, "key2", nullptr);
113 EXPECT_EQ(ret, OH_HTTP_PARAMETER_ERROR);
114 OH_Http_DestroyHeaders(&header);
115 }
116
117 HWTEST_F(NetHttpTest, SetHeaderValue002, TestSize.Level1)
118 {
119 Http_Headers *header = OH_Http_CreateHeaders();
120 EXPECT_TRUE(header != nullptr);
121 OH_Http_SetHeaderValue(header, "key1", "test1");
122
123 uint32_t ret = OH_Http_SetHeaderValue(header, "key2", "test2");
124 EXPECT_EQ(ret, OH_HTTP_RESULT_OK);
125 OH_Http_DestroyHeaders(&header);
126 }
127
128 HWTEST_F(NetHttpTest, SetHeaderValue003, TestSize.Level1)
129 {
130 Http_Headers *header = OH_Http_CreateHeaders();
131 EXPECT_TRUE(header != nullptr);
132 OH_Http_SetHeaderValue(header, "key1", "test1");
133
134 uint32_t ret = OH_Http_SetHeaderValue(header, "key1", "test1");
135 EXPECT_EQ(ret, OH_HTTP_RESULT_OK);
136 OH_Http_DestroyHeaders(&header);
137 }
138
139 HWTEST_F(NetHttpTest, SetHeaderValue004, TestSize.Level1)
140 {
141 Http_Headers *header = OH_Http_CreateHeaders();
142 EXPECT_TRUE(header != nullptr);
143 OH_Http_SetHeaderValue(header, "key1", "test1");
144
145 uint32_t ret = OH_Http_SetHeaderValue(header, "key1", "test2");
146 EXPECT_EQ(ret, OH_HTTP_RESULT_OK);
147 OH_Http_DestroyHeaders(&header);
148 }
149
150 HWTEST_F(NetHttpTest, SetHeaderValue005, TestSize.Level1)
151 {
152 Http_Headers *header = OH_Http_CreateHeaders();
153
154 EXPECT_TRUE(header != nullptr);
155 OH_Http_SetHeaderValue(header, "key1", "test1");
156 header->fields->capacity = MAX_MAP_CAPACITY + 1;
157 uint32_t ret = OH_Http_SetHeaderValue(header, "key1", "test2");
158 EXPECT_EQ(ret, OH_HTTP_PARAMETER_ERROR);
159 OH_Http_DestroyHeaders(&header);
160 }
161
162 HWTEST_F(NetHttpTest, GetHeaderValue001, TestSize.Level1)
163 {
164 Http_Headers *header = OH_Http_CreateHeaders();
165 EXPECT_TRUE(header != nullptr);
166 header->fields = nullptr;
167 Http_HeaderValue *value = OH_Http_GetHeaderValue(header, "key");
168 EXPECT_EQ(value, nullptr);
169 OH_Http_DestroyHeaders(&header);
170 }
171
172 HWTEST_F(NetHttpTest, GetHeaderValue002, TestSize.Level1)
173 {
174 Http_HeaderValue *value = OH_Http_GetHeaderValue(nullptr, "key");
175 EXPECT_EQ(value, nullptr);
176
177 Http_Headers *header = OH_Http_CreateHeaders();
178 EXPECT_TRUE(header != nullptr);
179 value = OH_Http_GetHeaderValue(header, nullptr);
180 EXPECT_EQ(value, nullptr);
181 OH_Http_DestroyHeaders(&header);
182 }
183
184 HWTEST_F(NetHttpTest, GetHeaderValue003, TestSize.Level1)
185 {
186 Http_Headers *header = OH_Http_CreateHeaders();
187 EXPECT_TRUE(header != nullptr);
188 OH_Http_SetHeaderValue(header, "key1", "test1");
189 Http_HeaderValue *value = OH_Http_GetHeaderValue(header, "key1");
190 EXPECT_TRUE(value != nullptr);
191 OH_Http_DestroyHeaders(&header);
192 }
193
194 HWTEST_F(NetHttpTest, GetHeaderEntries001, TestSize.Level1)
195 {
196 EXPECT_EQ(OH_Http_GetHeaderEntries(nullptr), nullptr);
197
198 Http_Headers *header = OH_Http_CreateHeaders();
199 EXPECT_TRUE(header != nullptr);
200 header->fields = nullptr;
201 EXPECT_EQ(OH_Http_GetHeaderEntries(header), nullptr);
202 OH_Http_DestroyHeaders(&header);
203 }
204
205 HWTEST_F(NetHttpTest, GetHeaderEntries002, TestSize.Level1)
206 {
207 Http_Headers *header = OH_Http_CreateHeaders();
208 EXPECT_TRUE(header != nullptr);
209 header->fields->capacity = MAX_MAP_CAPACITY + 1;
210 EXPECT_EQ(OH_Http_GetHeaderEntries(header), nullptr);
211 OH_Http_DestroyHeaders(&header);
212 }
213
214 HWTEST_F(NetHttpTest, GetHeaderEntries003, TestSize.Level1)
215 {
216 Http_Headers *header = OH_Http_CreateHeaders();
217 EXPECT_TRUE(header != nullptr);
218 OH_Http_SetHeaderValue(header, "a", "test1");
219 OH_Http_SetHeaderValue(header, "cc", "test2");
220 OH_Http_SetHeaderValue(header, "b", "test3");
221 Http_HeaderEntry *entries = OH_Http_GetHeaderEntries(header);
222 EXPECT_TRUE(entries != nullptr);
223 OH_Http_DestroyHeaderEntries(&entries);
224 OH_Http_DestroyHeaders(&header);
225 OH_Http_DestroyHeaderEntries(nullptr);
226 }
227
228 HWTEST_F(NetHttpTest, CreateRequest001, TestSize.Level1)
229 {
230 EXPECT_EQ(OH_Http_CreateRequest(nullptr), nullptr);
231
232 const char *url = "https://www.baidu.com";
233 EXPECT_TRUE(OH_Http_CreateRequest(url) != nullptr);
234 }
235
236 HWTEST_F(NetHttpTest, SetOption001, TestSize.Level1)
237 {
238 Http_Request *request = OH_Http_CreateRequest("https://www.baidu.com");
239 request->options = (Http_RequestOptions *)calloc(1, sizeof(Http_RequestOptions));
240 Http_ResponseCallback callback = TestResponseCallback;
241 Http_EventsHandler handler;
242
243 request->options->method = "GET";
244 int ret = OH_Http_Request(request, callback, handler);
245 EXPECT_EQ(ret, 0);
246 free(request->options);
247 OH_Http_Destroy(&request);
248 }
249
250 HWTEST_F(NetHttpTest, SetOption002, TestSize.Level1)
251 {
252 Http_Request *request = OH_Http_CreateRequest("https://www.baidu.com");
253 request->options = (Http_RequestOptions *)calloc(1, sizeof(Http_RequestOptions));
254 Http_ResponseCallback callback = TestResponseCallback;
255 Http_EventsHandler handler;
256
257 request->options->priority = -1;
258 int ret = OH_Http_Request(request, callback, handler);
259 EXPECT_EQ(ret, 0);
260
261 request->options->priority = 2000;
262 ret = OH_Http_Request(request, callback, handler);
263 EXPECT_EQ(ret, 0);
264
265 request->options->priority = 1;
266 ret = OH_Http_Request(request, callback, handler);
267 EXPECT_EQ(ret, 0);
268
269 request->options->readTimeout = 10;
270 ret = OH_Http_Request(request, callback, handler);
271 EXPECT_EQ(ret, 0);
272
273 request->options->connectTimeout = 10;
274 ret = OH_Http_Request(request, callback, handler);
275 EXPECT_EQ(ret, 0);
276
277 Http_Headers *header = OH_Http_CreateHeaders();
278 EXPECT_TRUE(header != nullptr);
279 OH_Http_SetHeaderValue(header, "Accept", "application/json");
280 request->options->headers = header;
281 ret = OH_Http_Request(request, callback, handler);
282 EXPECT_EQ(ret, 0);
283 free(request->options);
284 OH_Http_DestroyHeaders(&header);
285 OH_Http_Destroy(&request);
286 }
287
288 HWTEST_F(NetHttpTest, SetOption003, TestSize.Level1)
289 {
290 Http_Request *request = OH_Http_CreateRequest("https://www.baidu.com");
291 Http_ResponseCallback callback = TestResponseCallback;
292 Http_EventsHandler handler;
293 request->options = (Http_RequestOptions *)calloc(1, sizeof(Http_RequestOptions));
294
295 Http_Proxy httpProxy;
296 httpProxy.proxyType = Http_ProxyType::HTTP_PROXY_NOT_USE;
297 request->options->httpProxy = &httpProxy;
298 int ret = OH_Http_Request(request, callback, handler);
299 EXPECT_EQ(ret, 0);
300
301 httpProxy.customProxy.host = "host test";
302 ret = OH_Http_Request(request, callback, handler);
303 EXPECT_EQ(ret, 0);
304
305 httpProxy.customProxy.host = nullptr;
306 httpProxy.customProxy.exclusionLists = "exclusionLists test";
307 ret = OH_Http_Request(request, callback, handler);
308 EXPECT_EQ(ret, 0);
309
310 httpProxy.customProxy.host = "host test";
311 ret = OH_Http_Request(request, callback, handler);
312 EXPECT_EQ(ret, 0);
313
314 request->options->caPath = "capath test";
315 ret = OH_Http_Request(request, callback, handler);
316 EXPECT_EQ(ret, 0);
317
318 request->options->method = nullptr;
319 request->options->resumeFrom = 10;
320 request->options->resumeTo = 20;
321 ret = OH_Http_Request(request, callback, handler);
322 EXPECT_EQ(ret, 0);
323
324 request->options->method = "PUT";
325 request->options->resumeFrom = 10;
326 request->options->resumeTo = 20;
327 ret = OH_Http_Request(request, callback, handler);
328 EXPECT_EQ(ret, 0);
329
330 request->options->method = "GET";
331 request->options->resumeFrom = 10;
332 request->options->resumeTo = 20;
333 ret = OH_Http_Request(request, callback, handler);
334 EXPECT_EQ(ret, 0);
335 free(request->options);
336 OH_Http_Destroy(&request);
337 }
338
339 HWTEST_F(NetHttpTest, SetOtherOption001, TestSize.Level1)
340 {
341 Http_Request *request = OH_Http_CreateRequest("https://www.baidu.com");
342 request->options = (Http_RequestOptions *)calloc(1, sizeof(Http_RequestOptions));
343 Http_ResponseCallback callback = TestResponseCallback;
344 Http_EventsHandler handler;
345 int ret = OH_Http_Request(request, callback, handler);
346 EXPECT_EQ(ret, 0);
347
348 std::string clientCertTest = "test";
349 request->options->clientCert = (Http_ClientCert *)calloc(1, sizeof(Http_ClientCert));
350 request->options->clientCert->certPath = strdup(clientCertTest.c_str());
351 ret = OH_Http_Request(request, callback, handler);
352 EXPECT_EQ(ret, 0);
353
354 request->options->clientCert->keyPassword = strdup(clientCertTest.c_str());
355 ret = OH_Http_Request(request, callback, handler);
356 EXPECT_EQ(ret, 0);
357
358 request->options->clientCert->keyPath = strdup(clientCertTest.c_str());
359 ret = OH_Http_Request(request, callback, handler);
360 EXPECT_EQ(ret, 0);
361
362 request->options->clientCert->type = Http_CertType::OH_HTTP_PEM;
363 ret = OH_Http_Request(request, callback, handler);
364 EXPECT_EQ(ret, 0);
365
366 request->options->clientCert->type = Http_CertType::OH_HTTP_DER;
367 ret = OH_Http_Request(request, callback, handler);
368 EXPECT_EQ(ret, 0);
369
370 request->options->clientCert->type = Http_CertType::OH_HTTP_P12;
371 ret = OH_Http_Request(request, callback, handler);
372 EXPECT_EQ(ret, 0);
373
374 request->options->addressFamily = Http_AddressFamilyType::HTTP_ADDRESS_FAMILY_ONLY_V4;
375 ret = OH_Http_Request(request, callback, handler);
376 EXPECT_EQ(ret, 0);
377
378 request->options->addressFamily = Http_AddressFamilyType::HTTP_ADDRESS_FAMILY_ONLY_V6;
379 ret = OH_Http_Request(request, callback, handler);
380 EXPECT_EQ(ret, 0);
381
382 request->options->addressFamily = Http_AddressFamilyType::HTTP_ADDRESS_FAMILY_DEFAULT;
383 ret = OH_Http_Request(request, callback, handler);
384 EXPECT_EQ(ret, 0);
385 free(request->options->clientCert->certPath);
386 free(request->options->clientCert->keyPassword);
387 free(request->options->clientCert->keyPath);
388 free(request->options->clientCert);
389 free(request->options);
390 OH_Http_Destroy(&request);
391 }
392
393 HWTEST_F(NetHttpTest, HttpRequest001, TestSize.Level1)
394 {
395 Http_ResponseCallback callback = TestResponseCallback;
396 Http_Request *request = OH_Http_CreateRequest("https://www.baidu.com");
397 Http_EventsHandler handler;
398 EXPECT_EQ(OH_Http_Request(nullptr, callback, handler), HTTP_OUT_OF_MEMORY);
399 EXPECT_EQ(OH_Http_Request(request, nullptr, handler), HTTP_OUT_OF_MEMORY);
400 OH_Http_Destroy(&request);
401 }
402
403 HWTEST_F(NetHttpTest, HttpRequest002, TestSize.Level1)
404 {
405 Http_ResponseCallback callback = TestResponseCallback;
406 Http_Request *req = OH_Http_CreateRequest("https://www.baidu.com");
407 req->options = (Http_RequestOptions *)calloc(1, sizeof(Http_RequestOptions));
408 req->options->httpProtocol = Http_HttpProtocol::OH_HTTP1_1;
409 Http_EventsHandler handler;
410 EXPECT_EQ(OH_Http_Request(req, callback, handler), 0);
411 OH_Http_Destroy(&req);
412 }
413
414 HWTEST_F(NetHttpTest, HttpDestroy001, TestSize.Level1)
415 {
416 OH_Http_Destroy(nullptr);
417
418 Http_Request *req = OH_Http_CreateRequest("https://www.baidu.com");
419 EXPECT_TRUE(req != nullptr);
420 OH_Http_Destroy(&req);
421
422 Http_ResponseCallback callback = TestResponseCallback;
423 Http_EventsHandler handler;
424 req = OH_Http_CreateRequest("https://www.baidu.com");
425 EXPECT_TRUE(req != nullptr);
426 OH_Http_Request(req, callback, handler);
427 OH_Http_Destroy(&req);
428
429 req = OH_Http_CreateRequest("https://www.baidu.com");
430 EXPECT_TRUE(req != nullptr);
431 OH_Http_Request(req, callback, handler);
432 OH_Http_Destroy(&req);
433 OH_Http_Destroy(&req);
434 }
435
436 HWTEST_F(NetHttpTest, RequestOnSuccess001, TestSize.Level1)
437 {
438 Http_Request *req = OH_Http_CreateRequest("https://www.baidu.com");
439 EXPECT_TRUE(req != nullptr);
440
441 Http_ResponseCallback callback = TestResponseCallback;
442 Http_EventsHandler handler;
443 OH_Http_Request(req, callback, handler);
444 OH_Http_Destroy(&req);
445 }
446
447 HWTEST_F(NetHttpTest, RequestOnSuccess002, TestSize.Level1)
448 {
449 Http_Request *request = OH_Http_CreateRequest("https://www.baidu.com");
450 EXPECT_TRUE(request != nullptr);
451
452 Http_ResponseCallback callback = TestResponseCallback;
453 Http_EventsHandler handler;
454 Http_OnVoidCallback onDataEndCallback = MyCallbackFunction;
455 handler.onDataEnd = onDataEndCallback;
456 OH_Http_Request(request, callback, handler);
457 OH_Http_Destroy(&request);
458 }
459
460 HWTEST_F(NetHttpTest, RequestOnCancel001, TestSize.Level1)
461 {
462 Http_Request *request = OH_Http_CreateRequest("https://www.baidu.com");
463 EXPECT_TRUE(request != nullptr);
464
465 Http_ResponseCallback callback = TestResponseCallback;
466 Http_EventsHandler handler;
467 OH_Http_Request(request, callback, handler);
468 OH_Http_Destroy(&request);
469 }
470
471 HWTEST_F(NetHttpTest, RequestOnCancel002, TestSize.Level1)
472 {
473 Http_Request *request = OH_Http_CreateRequest("https://www.baidu.com");
474 EXPECT_TRUE(request != nullptr);
475
476 Http_ResponseCallback callback = TestResponseCallback;
477 Http_EventsHandler handler;
478 Http_OnVoidCallback onDataEndCallback = MyCallbackFunction;
479 handler.onCanceled = onDataEndCallback;
480 OH_Http_Request(request, callback, handler);
481 OH_Http_Destroy(&request);
482 }
483
484 HWTEST_F(NetHttpTest, RequestOnFail001, TestSize.Level1)
485 {
486 Http_Request *request = OH_Http_CreateRequest("https://www.baidu.com");
487 EXPECT_TRUE(request != nullptr);
488
489 Http_ResponseCallback callback = TestResponseCallback;
490 Http_EventsHandler handler;
491 Http_OnVoidCallback onDataEndCallback = MyCallbackFunction;
492 handler.onDataEnd = onDataEndCallback;
493 OH_Http_Request(request, callback, handler);
494 OH_Http_Destroy(&request);
495 }
496
497 HWTEST_F(NetHttpTest, RequestOnDataReceive001, TestSize.Level1)
498 {
499 Http_Request *request = OH_Http_CreateRequest("https://www.baidu.com");
500 EXPECT_TRUE(request != nullptr);
501
502 Http_ResponseCallback callback = TestResponseCallback;
503 Http_EventsHandler handler;
504 Http_OnDataReceiveCallback onDataReceiveCallback = TestDataReceiveCallback;
505 handler.onDataReceive = onDataReceiveCallback;
506 OH_Http_Request(request, callback, handler);
507 OH_Http_Destroy(&request);
508 }
509
510 HWTEST_F(NetHttpTest, RequestOnHeadersReceive001, TestSize.Level1)
511 {
512 Http_Request *request = OH_Http_CreateRequest("https://www.baidu.com");
513
514 Http_EventsHandler handler;
515 Http_ResponseCallback callback = TestResponseCallback;
516 Http_OnHeaderReceiveCallback onHeaderReceiveCallback = testHeaderReceiveCallback;
517 handler.onHeadersReceive = onHeaderReceiveCallback;
518 OH_Http_Request(request, callback, handler);
519 OH_Http_Destroy(&request);
520 }
521 }