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