• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #include <iostream>
17 #include <cstring>
18 #include "gtest/gtest.h"
19 #include "http_client_constant.h"
20 #include "netstack_log.h"
21 #include "netstack_common_utils.h"
22 
23 #define private public
24 #include "http_client_task.h"
25 #include "http_client.h"
26 #include "http_client_error.h"
27 #include <curl/curl.h>
28 #include "http_client_request.h"
29 #include "http_client_response.h"
30 
31 using namespace OHOS::NetStack::HttpClient;
32 
33 class HttpClientTaskTest : public testing::Test {
34 public:
SetUpTestCase()35     static void SetUpTestCase() {}
36 
TearDownTestCase()37     static void TearDownTestCase() {}
38 
SetUp()39     virtual void SetUp() {}
40 
TearDown()41     virtual void TearDown() {}
42 
43     void ProcesslTaskCb(std::shared_ptr<HttpClientTask> task);
44 };
45 
46 namespace {
47 using namespace std;
48 using namespace testing::ext;
49 
50 HWTEST_F(HttpClientTaskTest, GetHttpVersionTest001, TestSize.Level1)
51 {
52     HttpClientRequest httpReq;
53     std::string url = "https://www.baidu.com";
54     httpReq.SetURL(url);
55 
56     HttpSession &session = HttpSession::GetInstance();
57     auto task = session.CreateTask(httpReq);
58 
59     uint32_t httpVersionTest = task->GetHttpVersion(HttpProtocol::HTTP_NONE);
60     EXPECT_EQ(httpVersionTest, CURL_HTTP_VERSION_NONE);
61 }
62 
63 HWTEST_F(HttpClientTaskTest, GetHttpVersionTest002, TestSize.Level1)
64 {
65     HttpClientRequest httpReq;
66     std::string url = "https://www.baidu.com";
67     httpReq.SetURL(url);
68     HttpSession &session = HttpSession::GetInstance();
69     auto task = session.CreateTask(httpReq);
70 
71     uint32_t httpVersionTest = task->GetHttpVersion(HttpProtocol::HTTP1_1);
72     EXPECT_EQ(httpVersionTest, CURL_HTTP_VERSION_1_1);
73 }
74 
75 HWTEST_F(HttpClientTaskTest, GetHttpVersionTest003, TestSize.Level1)
76 {
77     HttpClientRequest httpReq;
78     std::string url = "https://www.baidu.com";
79     httpReq.SetURL(url);
80     HttpSession &session = HttpSession::GetInstance();
81     auto task = session.CreateTask(httpReq);
82 
83     uint32_t httpVersionTest = task->GetHttpVersion(HttpProtocol::HTTP2);
84     EXPECT_EQ(httpVersionTest, CURL_HTTP_VERSION_2_0);
85 }
86 
87 HWTEST_F(HttpClientTaskTest, SetOtherCurlOptionTest001, TestSize.Level1)
88 {
89     HttpClientRequest httpReq;
90 
91     std::string url = "http://www.httpbin.org/get";
92     httpReq.SetURL(url);
93     httpReq.SetHttpProxyType(NOT_USE);
94     HttpProxy proxy;
95     proxy.host = "192.168.147.60";
96     proxy.port = 8888;
97     proxy.exclusions = "www.httpbin.org";
98     proxy.userpwd = "username:password";
99     proxy.tunnel = false;
100     httpReq.SetHttpProxy(proxy);
101 
102     HttpSession &session = HttpSession::GetInstance();
103     auto task = session.CreateTask(httpReq);
104 
105     bool result = task->SetOtherCurlOption(task->curlHandle_);
106     EXPECT_TRUE(result);
107 }
108 
109 HWTEST_F(HttpClientTaskTest, SetOtherCurlOptionTest002, TestSize.Level1)
110 {
111     HttpClientRequest httpReq;
112 
113     std::string url = "http://www.httpbin.org/get";
114     httpReq.SetURL(url);
115     httpReq.SetHttpProxyType(NOT_USE);
116     HttpProxy proxy;
117     proxy.host = "192.168.147.60";
118     proxy.port = 8888;
119     proxy.userpwd = "username:password";
120     proxy.tunnel = false;
121     httpReq.SetHttpProxy(proxy);
122 
123     HttpSession &session = HttpSession::GetInstance();
124     auto task = session.CreateTask(httpReq);
125 
126     EXPECT_TRUE(task->SetOtherCurlOption(task->curlHandle_));
127 }
128 
129 HWTEST_F(HttpClientTaskTest, SetOtherCurlOptionTest003, TestSize.Level1)
130 {
131     HttpClientRequest httpReq;
132 
133     std::string url = "http://www.httpbin.org/get";
134     httpReq.SetURL(url);
135     httpReq.SetHttpProxyType(NOT_USE);
136     HttpProxy proxy;
137     proxy.host = "192.168.147.60";
138     proxy.port = 8888;
139     proxy.tunnel = false;
140     httpReq.SetHttpProxy(proxy);
141 
142     HttpSession &session = HttpSession::GetInstance();
143     auto task = session.CreateTask(httpReq);
144 
145     EXPECT_TRUE(task->SetOtherCurlOption(task->curlHandle_));
146 }
147 
148 HWTEST_F(HttpClientTaskTest, SetOtherCurlOptionTest004, TestSize.Level1)
149 {
150     HttpClientRequest httpReq;
151 
152     std::string url = "http://www.httpbin.org/get";
153     httpReq.SetURL(url);
154     httpReq.SetHttpProxyType(NOT_USE);
155     HttpProxy proxy;
156     proxy.host = "192.168.147.60";
157     proxy.port = 8888;
158     proxy.exclusions = "www.httpbin.org";
159     proxy.tunnel = true;
160     httpReq.SetHttpProxy(proxy);
161 
162     HttpSession &session = HttpSession::GetInstance();
163     auto task = session.CreateTask(httpReq);
164 
165     EXPECT_TRUE(task->SetOtherCurlOption(task->curlHandle_));
166     curl_easy_cleanup(task->curlHandle_);
167     task->curlHandle_ = nullptr;
168 }
169 
170 HWTEST_F(HttpClientTaskTest, SetUploadOptionsTest001, TestSize.Level1)
171 {
172     HttpClientRequest httpReq;
173     std::string url = "http://www.httpbin.org/put";
174     httpReq.SetURL(url);
175     std::string method = "PUT";
176     httpReq.SetMethod(method);
177 
178     HttpSession &session = HttpSession::GetInstance();
179     std::string filePath = "/bin/who";
180     auto task = session.CreateTask(httpReq, UPLOAD, filePath);
181 
182     EXPECT_TRUE(task->SetUploadOptions(task->curlHandle_));
183 }
184 
185 HWTEST_F(HttpClientTaskTest, SetUploadOptionsTest002, TestSize.Level1)
186 {
187     HttpClientRequest httpReq;
188     std::string url = "http://www.httpbin.org/put";
189     httpReq.SetURL(url);
190     std::string method = "PUT";
191     httpReq.SetMethod(method);
192 
193     HttpSession &session = HttpSession::GetInstance();
194     std::string filePath = "";
195     auto task = session.CreateTask(httpReq, UPLOAD, filePath);
196 
197     EXPECT_FALSE(task->SetUploadOptions(task->curlHandle_));
198 }
199 
200 HWTEST_F(HttpClientTaskTest, SetCurlOptionsTest001, TestSize.Level1)
201 {
202     HttpClientRequest httpReq;
203     std::string url = "http://www.httpbin.org/get";
204     httpReq.SetURL(url);
205 
206     HttpSession &session = HttpSession::GetInstance();
207     auto task = session.CreateTask(httpReq);
208 
209     EXPECT_TRUE(task->SetCurlOptions());
210 }
211 
212 HWTEST_F(HttpClientTaskTest, SetCurlOptionsTest002, TestSize.Level1)
213 {
214     HttpClientRequest httpReq;
215     std::string url = "http://www.httpbin.org/get";
216     httpReq.SetURL(url);
217 
218     HttpSession &session = HttpSession::GetInstance();
219     auto task = session.CreateTask(httpReq);
220 
221     task->request_.SetMethod(HttpConstant::HTTP_METHOD_HEAD);
222 
223     EXPECT_TRUE(task->SetCurlOptions());
224 }
225 
226 HWTEST_F(HttpClientTaskTest, SetCurlOptionsTest003, TestSize.Level1)
227 {
228     HttpClientRequest httpReq;
229     std::string url = "http://www.httpbin.org/put";
230     httpReq.SetURL(url);
231     std::string method = "PUT";
232     httpReq.SetMethod(method);
233 
234     HttpSession &session = HttpSession::GetInstance();
235     std::string filePath = "/bin/who";
236     auto task = session.CreateTask(httpReq, UPLOAD, filePath);
237 
238     task->curlHandle_ = nullptr;
239     EXPECT_FALSE(task->SetCurlOptions());
240 }
241 
242 HWTEST_F(HttpClientTaskTest, SetCurlOptionsTest004, TestSize.Level1)
243 {
244     HttpClientRequest httpReq;
245     std::string url = "http://www.httpbin.org/get";
246     httpReq.SetURL(url);
247 
248     HttpSession &session = HttpSession::GetInstance();
249     auto task = session.CreateTask(httpReq);
250 
251     task->request_.SetMethod(HttpConstant::HTTP_METHOD_POST);
252 
253     EXPECT_TRUE(task->SetCurlOptions());
254 }
255 
256 HWTEST_F(HttpClientTaskTest, SetCurlOptionsTest005, TestSize.Level1)
257 {
258     HttpClientRequest httpReq;
259     std::string url = "http://www.httpbin.org/get";
260     httpReq.SetURL(url);
261 
262     HttpSession &session = HttpSession::GetInstance();
263     auto task = session.CreateTask(httpReq);
264 
265     task->curlHandle_ = nullptr;
266 
267     EXPECT_FALSE(task->SetCurlOptions());
268 }
269 
270 HWTEST_F(HttpClientTaskTest, GetType001, TestSize.Level1)
271 {
272     HttpClientRequest httpReq;
273     std::string url = "https://www.baidu.com";
274     httpReq.SetURL(url);
275 
276     HttpSession &session = HttpSession::GetInstance();
277     auto task = session.CreateTask(httpReq);
278 
279     EXPECT_EQ(TaskType::DEFAULT, task->GetType());
280 }
281 
282 HWTEST_F(HttpClientTaskTest, GetFilePathTest001, TestSize.Level1)
283 {
284     HttpClientRequest httpReq;
285     std::string url = "http://www.httpbin.org/put";
286     httpReq.SetURL(url);
287     std::string method = "PUT";
288     httpReq.SetMethod(method);
289 
290     HttpSession &session = HttpSession::GetInstance();
291     std::string filePath = "/bin/who";
292     auto task = session.CreateTask(httpReq, UPLOAD, filePath);
293 
294     EXPECT_EQ(task->GetFilePath(), "/bin/who");
295 }
296 HWTEST_F(HttpClientTaskTest, GetTaskIdTest001, TestSize.Level1)
297 {
298     HttpClientRequest httpReq;
299     std::string url = "http://www.httpbin.org/get";
300     httpReq.SetURL(url);
301 
302     HttpSession &session = HttpSession::GetInstance();
303     auto task = session.CreateTask(httpReq);
304 
305     unsigned int taskId = task->GetTaskId();
306     EXPECT_TRUE(taskId >= 0);
307 }
308 
309 HWTEST_F(HttpClientTaskTest, OnSuccessTest001, TestSize.Level1)
310 {
311     HttpClientRequest httpReq;
312     std::string url = "https://www.baidu.com";
313     httpReq.SetURL(url);
314 
315     HttpSession &session = HttpSession::GetInstance();
316     auto task = session.CreateTask(httpReq);
__anonc4615ecd0202(const HttpClientRequest &request, const HttpClientResponse &response) 317     task->OnSuccess([task](const HttpClientRequest &request, const HttpClientResponse &response) {});
318 
319     EXPECT_TRUE(task->onSucceeded_ != nullptr);
320 }
321 
322 HWTEST_F(HttpClientTaskTest, OnCancelTest001, TestSize.Level1)
323 {
324     HttpClientRequest httpReq;
325     std::string url = "http://www.httpbin.org/get";
326     httpReq.SetURL(url);
327 
328     HttpSession &session = HttpSession::GetInstance();
329     auto task = session.CreateTask(httpReq);
330 
__anonc4615ecd0302(const HttpClientRequest &request, const HttpClientResponse &response) 331     task->OnCancel([](const HttpClientRequest &request, const HttpClientResponse &response) {});
332 
333     EXPECT_TRUE(task->onCanceled_ != nullptr);
334 }
335 
336 HWTEST_F(HttpClientTaskTest, OnFailTest001, TestSize.Level1)
337 {
338     HttpClientRequest httpReq;
339     std::string url = "http://www.httpbin.org/get";
340     httpReq.SetURL(url);
341 
342     HttpSession &session = HttpSession::GetInstance();
343     auto task = session.CreateTask(httpReq);
344 
345     task->OnFail(
__anonc4615ecd0402(const HttpClientRequest &request, const HttpClientResponse &response, const HttpClientError &error) 346         [](const HttpClientRequest &request, const HttpClientResponse &response, const HttpClientError &error) {});
347 
348     EXPECT_TRUE(task->onFailed_ != nullptr);
349 }
350 
351 HWTEST_F(HttpClientTaskTest, OnDataReceiveTest001, TestSize.Level1)
352 {
353     HttpClientRequest httpReq;
354     std::string url = "http://www.httpbin.org/get";
355     httpReq.SetURL(url);
356 
357     HttpSession &session = HttpSession::GetInstance();
358     auto task = session.CreateTask(httpReq);
359 
__anonc4615ecd0502(const HttpClientRequest &request, const uint8_t *data, size_t length) 360     task->OnDataReceive([](const HttpClientRequest &request, const uint8_t *data, size_t length) {});
361 
362     EXPECT_TRUE(task->onDataReceive_ != nullptr);
363 }
364 
365 HWTEST_F(HttpClientTaskTest, OnProgressTest001, TestSize.Level1)
366 {
367     HttpClientRequest httpReq;
368     std::string url = "http://www.httpbin.org/get";
369     httpReq.SetURL(url);
370 
371     HttpSession &session = HttpSession::GetInstance();
372     auto task = session.CreateTask(httpReq);
373 
374     task->OnProgress(
__anonc4615ecd0602(const HttpClientRequest &request, u_long dltotal, u_long dlnow, u_long ultotal, u_long ulnow) 375         [](const HttpClientRequest &request, u_long dltotal, u_long dlnow, u_long ultotal, u_long ulnow) {});
376 
377     EXPECT_TRUE(task->onProgress_ != nullptr);
378 }
379 
380 HWTEST_F(HttpClientTaskTest, DataReceiveCallbackTest001, TestSize.Level1)
381 {
382     HttpClientRequest httpReq;
383     std::string url = "https://www.baidu.com";
384     const char *data = "https://www.baidu.com";
385     httpReq.SetURL(url);
386 
387     HttpSession &session = HttpSession::GetInstance();
388     auto task = session.CreateTask(httpReq);
389 
390     unsigned int taskId = task->GetTaskId();
391     std::lock_guard<std::mutex> lock(session.taskQueueMutex_);
392     session.taskIdMap_[taskId] = task;
393 
394     unsigned int *userData = &taskId;
395     size_t size = 10;
396     size_t memBytes = 1;
397 
__anonc4615ecd0702(const HttpClientRequest &request, const uint8_t *data, size_t length) 398     task->OnDataReceive([](const HttpClientRequest &request, const uint8_t *data, size_t length) {});
399     size_t result = task->DataReceiveCallback(data, size, memBytes, userData);
400 
401     EXPECT_EQ(result, size * memBytes);
402     session.taskIdMap_.erase(taskId);
403 }
404 
405 HWTEST_F(HttpClientTaskTest, DataReceiveCallbackTest002, TestSize.Level1)
406 {
407     HttpClientRequest httpReq;
408     std::string url = "https://www.baidu.com";
409     const char *data = "https://www.baidu.com";
410     httpReq.SetURL(url);
411 
412     HttpSession &session = HttpSession::GetInstance();
413     auto task = session.CreateTask(httpReq);
414 
415     unsigned int taskId = task->GetTaskId();
416     unsigned int *userData = &taskId;
417     size_t size = 10;
418     size_t memBytes = 1;
419     size_t result = task->DataReceiveCallback(data, size, memBytes, userData);
420 
421     EXPECT_EQ(result, 0);
422 }
423 
424 HWTEST_F(HttpClientTaskTest, DataReceiveCallbackTest003, TestSize.Level1)
425 {
426     HttpClientRequest httpReq;
427     std::string url = "http://www.httpbin.org/get";
428     const char *data = "http://www.httpbin.org/get";
429     httpReq.SetURL(url);
430 
431     HttpSession &session = HttpSession::GetInstance();
432     auto task = session.CreateTask(httpReq);
433 
434     unsigned int taskId = task->GetTaskId();
435     std::lock_guard<std::mutex> lock(session.taskQueueMutex_);
436     session.taskIdMap_[taskId] = task;
437 
438     unsigned int *userData = &taskId;
439     size_t size = 10;
440     size_t memBytes = 1;
441     task->canceled_ = true;
442     size_t result = task->DataReceiveCallback(data, size, memBytes, userData);
443 
444     EXPECT_EQ(result, 0);
445     task->canceled_ = false;
446     session.taskIdMap_.erase(taskId);
447 }
448 
449 HWTEST_F(HttpClientTaskTest, ProgressCallbackTest001, TestSize.Level1)
450 {
451     HttpClientRequest httpReq;
452     std::string url = "https://www.baidu.com";
453     httpReq.SetURL(url);
454 
455     HttpSession &session = HttpSession::GetInstance();
456     auto task = session.CreateTask(httpReq);
457 
458     unsigned int taskId = task->GetTaskId();
459     unsigned int *userData = &taskId;
460     curl_off_t dltotal = 100;
461     curl_off_t dlnow = 50;
462     curl_off_t ultotal = 200;
463     curl_off_t ulnow = 100;
464     int result;
465 
466     result = task->ProgressCallback(userData, dltotal, dlnow, ultotal, ulnow);
467     EXPECT_EQ(result, 0);
468 }
469 
470 HWTEST_F(HttpClientTaskTest, ProgressCallbackTest002, TestSize.Level1)
471 {
472     HttpClientRequest httpReq;
473     std::string url = "https://www.baidu.com";
474     httpReq.SetURL(url);
475 
476     HttpSession &session = HttpSession::GetInstance();
477     auto task = session.CreateTask(httpReq);
478 
479     unsigned int taskId = task->GetTaskId();
480     std::lock_guard<std::mutex> lock(session.taskQueueMutex_);
481     session.taskIdMap_[taskId] = task;
482 
483     unsigned int *userData = &taskId;
484     curl_off_t dltotal = 100;
485     curl_off_t dlnow = 50;
486     curl_off_t ultotal = 200;
487     curl_off_t ulnow = 100;
488     int result;
489 
490     task->Cancel();
491     result = task->ProgressCallback(userData, dltotal, dlnow, ultotal, ulnow);
492     EXPECT_EQ(result, CURLE_ABORTED_BY_CALLBACK);
493     session.taskIdMap_.erase(taskId);
494 }
495 
496 HWTEST_F(HttpClientTaskTest, ProgressCallbackTest003, TestSize.Level1)
497 {
498     HttpClientRequest httpReq;
499     std::string url = "https://www.baidu.com";
500     httpReq.SetURL(url);
501 
502     HttpSession &session = HttpSession::GetInstance();
503     auto task = session.CreateTask(httpReq);
504 
505     unsigned int taskId = task->GetTaskId();
506     std::lock_guard<std::mutex> lock(session.taskQueueMutex_);
507     session.taskIdMap_[taskId] = task;
508 
509     unsigned int *userData = &taskId;
510     curl_off_t dltotal = 100;
511     curl_off_t dlnow = 50;
512     curl_off_t ultotal = 200;
513     curl_off_t ulnow = 100;
514 
515     int result;
516     result = task->ProgressCallback(userData, dltotal, dlnow, ultotal, ulnow);
517     EXPECT_EQ(result, 0);
518     session.taskIdMap_.erase(taskId);
519 }
520 
521 HWTEST_F(HttpClientTaskTest, HeaderReceiveCallbackTest001, TestSize.Level1)
522 {
523     HttpClientRequest httpReq;
524     std::string url = "https://www.baidu.com";
525     httpReq.SetURL(url);
526 
527     HttpSession &session = HttpSession::GetInstance();
528     auto task = session.CreateTask(httpReq);
529 
530     unsigned int taskId = task->GetTaskId();
531     std::lock_guard<std::mutex> lock(session.taskQueueMutex_);
532     session.taskIdMap_[taskId] = task;
533 
534     unsigned int *userData = &taskId;
535     const char *data = "Test Header";
536     size_t size = 5;
537     size_t memBytes = 2;
538     size_t result = task->HeaderReceiveCallback(data, size, memBytes, userData);
539     EXPECT_EQ(result, size * memBytes);
540     session.taskIdMap_.erase(taskId);
541 }
542 
543 HWTEST_F(HttpClientTaskTest, HeaderReceiveCallbackTest002, TestSize.Level1)
544 {
545     HttpClientRequest httpReq;
546     std::string url = "https://www.baidu.com";
547     httpReq.SetURL(url);
548 
549     HttpSession &session = HttpSession::GetInstance();
550     auto task = session.CreateTask(httpReq);
551 
552     unsigned int taskId = task->GetTaskId();
553     unsigned int *userData = &taskId;
554 
555     const char *data = "Test Header";
556     size_t size = 5 * 1024 * 1024;
557     size_t memBytes = 2;
558     size_t result = task->HeaderReceiveCallback(data, size, memBytes, userData);
559     EXPECT_EQ(result, 0);
560 }
561 
562 HWTEST_F(HttpClientTaskTest, HeaderReceiveCallbackTest003, TestSize.Level1)
563 {
564     HttpClientRequest httpReq;
565     std::string url = "http://www.httpbin.org/get";
566     httpReq.SetURL(url);
567 
568     HttpSession &session = HttpSession::GetInstance();
569     auto task = session.CreateTask(httpReq);
570 
571     unsigned int taskId = task->GetTaskId();
572     unsigned int *userData = &taskId;
573 
574     const char *data = "Test Header";
575     size_t size = 5;
576     size_t memBytes = 2;
577     size_t result = task->HeaderReceiveCallback(data, size, memBytes, userData);
578     EXPECT_EQ(result, 0);
579 }
580 
581 HWTEST_F(HttpClientTaskTest, ProcessResponseCodeTest001, TestSize.Level1)
582 {
583     HttpClientRequest httpReq;
584     std::string url = "https://www.baidu.com";
585     httpReq.SetURL(url);
586 
587     HttpSession &session = HttpSession::GetInstance();
588     auto task = session.CreateTask(httpReq);
589     task->Start();
590 
591     while (task->GetStatus() != TaskStatus::IDLE) {
592         std::this_thread::sleep_for(std::chrono::milliseconds(100));
593     }
594     EXPECT_TRUE(task->ProcessResponseCode());
595 }
596 
597 HWTEST_F(HttpClientTaskTest, ProcessResponseTest001, TestSize.Level1)
598 {
599     HttpClientRequest httpReq;
600     std::string url = "https://www.baidu.com";
601     httpReq.SetURL(url);
602 
603     HttpSession &session = HttpSession::GetInstance();
604     auto task = session.CreateTask(httpReq);
605 
606     CURLMsg msg;
607     msg.data.result = CURLE_ABORTED_BY_CALLBACK;
__anonc4615ecd0802(const HttpClientRequest &request, const HttpClientResponse &response) 608     task->OnCancel([](const HttpClientRequest &request, const HttpClientResponse &response) {});
609     task->ProcessResponse(&msg);
610     EXPECT_TRUE(task->onCanceled_);
611 
612     msg.data.result = CURLE_FAILED_INIT;
613     task->OnFail(
__anonc4615ecd0902(const HttpClientRequest &request, const HttpClientResponse &response, const HttpClientError &error) 614         [](const HttpClientRequest &request, const HttpClientResponse &response, const HttpClientError &error) {});
615     task->ProcessResponse(&msg);
616     EXPECT_TRUE(task->onFailed_);
617 
618     msg.data.result = CURLE_OK;
619     task->response_.SetResponseCode(ResponseCode::NOT_MODIFIED);
__anonc4615ecd0a02(const HttpClientRequest &request, const HttpClientResponse &response) 620     task->OnSuccess([task](const HttpClientRequest &request, const HttpClientResponse &response) {});
621     task->ProcessResponse(&msg);
622     EXPECT_TRUE(task->onSucceeded_);
623 
624     task->curlHandle_ = nullptr;
625     task->OnFail(
__anonc4615ecd0b02(const HttpClientRequest &request, const HttpClientResponse &response, const HttpClientError &error) 626         [](const HttpClientRequest &request, const HttpClientResponse &response, const HttpClientError &error) {});
627     task->ProcessResponse(&msg);
628     EXPECT_TRUE(task->onFailed_);
629 }
630 
631 HWTEST_F(HttpClientTaskTest, SetResponseTest001, TestSize.Level1)
632 {
633     HttpClientRequest httpReq;
634     std::string url = "https://www.baidu.com";
635     httpReq.SetURL(url);
636 
637     HttpSession &session = HttpSession::GetInstance();
638     auto task = session.CreateTask(httpReq);
639 
640     HttpClientResponse resp;
641     resp.result_ = "result1";
642     task->SetResponse(resp);
643 
644     EXPECT_EQ(task->response_.result_, "result1");
645 }
646 
647 HWTEST_F(HttpClientTaskTest, GetHttpProxyInfoTest001, TestSize.Level1)
648 {
649     HttpClientRequest httpReq;
650 
651     std::string url = "http://www.httpbin.org/get";
652     httpReq.SetURL(url);
653     httpReq.SetHttpProxyType(USE_SPECIFIED);
654     HttpProxy proxy;
655     proxy.host = "192.168.147.60";
656     proxy.port = 8888;
657     proxy.exclusions = "www.httpbin.org";
658     proxy.userpwd = "username:password";
659     proxy.tunnel = false;
660     httpReq.SetHttpProxy(proxy);
661 
662     HttpSession &session = HttpSession::GetInstance();
663     auto task = session.CreateTask(httpReq);
664 
665     std::string host, exclusions, userpwd;
666     int32_t port = 0;
667     bool tunnel = false;
668     task->GetHttpProxyInfo(host, port, exclusions, userpwd, tunnel);
669 
670     EXPECT_EQ(host, "192.168.147.60");
671     EXPECT_EQ(port, 8888);
672     EXPECT_EQ(exclusions, "www.httpbin.org");
673     EXPECT_EQ(userpwd, "username:password");
674     EXPECT_FALSE(tunnel);
675 }
676 
677 HWTEST_F(HttpClientTaskTest, GetHttpProxyInfoTest002, TestSize.Level1)
678 {
679     HttpClientRequest httpReq;
680 
681     std::string url = "http://www.httpbin.org/get";
682     httpReq.SetURL(url);
683     httpReq.SetHttpProxyType(NOT_USE);
684     HttpProxy proxy;
685     proxy.host = "192.168.147.60";
686     proxy.port = 8888;
687     proxy.exclusions = "www.httpbin.org";
688     proxy.userpwd = "username:password";
689     proxy.tunnel = false;
690     httpReq.SetHttpProxy(proxy);
691 
692     HttpSession &session = HttpSession::GetInstance();
693     auto task = session.CreateTask(httpReq);
694 
695     std::string host, exclusions, userpwd;
696     int32_t port = 0;
697     bool tunnel = false;
698     task->GetHttpProxyInfo(host, port, exclusions, userpwd, tunnel);
699 
700     EXPECT_EQ(host, "");
701     EXPECT_EQ(port, 0);
702     EXPECT_EQ(exclusions, "");
703     EXPECT_EQ(userpwd, "");
704     EXPECT_FALSE(tunnel);
705 }
706 
707 HWTEST_F(HttpClientTaskTest, SetStatus001, TestSize.Level1)
708 {
709     HttpClientRequest httpReq;
710     std::string url = "http://www.httpbin.org/get";
711     httpReq.SetURL(url);
712 
713     HttpSession &session = HttpSession::GetInstance();
714     auto task = session.CreateTask(httpReq);
715 
716     task->SetStatus(RUNNING);
717     EXPECT_EQ(RUNNING, task->GetStatus());
718 }
719 
720 HWTEST_F(HttpClientTaskTest, GetStatusTest001, TestSize.Level1)
721 {
722     HttpClientRequest httpReq;
723     std::string url = "http://www.httpbin.org/get";
724     httpReq.SetURL(url);
725 
726     HttpSession &session = HttpSession::GetInstance();
727     auto task = session.CreateTask(httpReq);
728 
729     EXPECT_EQ(IDLE, task->GetStatus());
730 }
731 
732 HWTEST_F(HttpClientTaskTest, GetStatusTest002, TestSize.Level1)
733 {
734     HttpClientRequest httpReq;
735     std::string url = "https://www.baidu.com";
736     httpReq.SetURL(url);
737 
738     HttpSession &session = HttpSession::GetInstance();
739     auto task = session.CreateTask(httpReq);
740 
741     task->SetStatus(TaskStatus::RUNNING);
742 
743     EXPECT_EQ(task->GetStatus(), RUNNING);
744 }
745 
746 HWTEST_F(HttpClientTaskTest, StartTest001, TestSize.Level1)
747 {
748     HttpClientRequest httpReq;
749     std::string url = "http://www.baidu.com";
750     httpReq.SetURL(url);
751 
752     HttpSession &session = HttpSession::GetInstance();
753     auto task = session.CreateTask(httpReq);
754 
755     task->SetStatus(TaskStatus::RUNNING);
756     bool result = task->Start();
757     EXPECT_FALSE(result);
758 }
759 
760 HWTEST_F(HttpClientTaskTest, StartTest002, TestSize.Level1)
761 {
762     HttpClientRequest httpReq;
763     std::string url = "http://www.baidu.com";
764     httpReq.SetURL(url);
765 
766     HttpSession &session = HttpSession::GetInstance();
767     auto task = session.CreateTask(httpReq);
768 
769     task->error_.SetErrorCode(HttpErrorCode::HTTP_UNSUPPORTED_PROTOCOL);
770     bool result = task->Start();
771     EXPECT_FALSE(result);
772 }
773 
774 HWTEST_F(HttpClientTaskTest, ProcessCookieTest001, TestSize.Level1)
775 {
776     HttpClientRequest httpReq;
777     std::string url = "http://www.httpbin.org/cookies/set/name1/value1";
778     httpReq.SetURL(url);
779     httpReq.SetHeader("content-type", "text/plain");
780     HttpSession &session = HttpSession::GetInstance();
781     auto task = session.CreateTask(httpReq);
782     task->Start();
783 
784     while (task->GetStatus() != TaskStatus::IDLE) {
785         std::this_thread::sleep_for(std::chrono::milliseconds(5));
786     }
787     EXPECT_EQ(task->GetResponse().GetResponseCode(), ResponseCode::NONE);
788     EXPECT_EQ("", task->GetResponse().GetCookies());
789 }
790 
791 HWTEST_F(HttpClientTaskTest, CancelTest001, TestSize.Level1)
792 {
793     HttpClientRequest httpReq;
794     std::string url = "https://www.baidu.com";
795     httpReq.SetURL(url);
796 
797     HttpSession &session = HttpSession::GetInstance();
798     auto task = session.CreateTask(httpReq);
799 
800     task->Cancel();
801     EXPECT_TRUE(task->canceled_);
802 }
803 
804 } // namespace