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