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 <cstring>
17 
18 #include "gtest/gtest.h"
19 #include "http_request_options.h"
20 #include "netstack_log.h"
21 #include "constant.h"
22 #include "secure_char.h"
23 #include "curl/curl.h"
24 #include "tlv_utils.h"
25 
26 using namespace OHOS::NetStack;
27 using namespace OHOS::NetStack::Http;
28 
29 class HttpRequestOptionsTest : public testing::Test {
30 public:
SetUpTestCase()31     static void SetUpTestCase() {}
32 
TearDownTestCase()33     static void TearDownTestCase() {}
34 
SetUp()35     virtual void SetUp() {}
36 
TearDown()37     virtual void TearDown() {}
38 };
39 
40 namespace {
41 using namespace std;
42 using namespace testing::ext;
43 constexpr char OTHER_CA_PATH[] = "/etc/ssl/certs/other.pem";
44 
45 HWTEST_F(HttpRequestOptionsTest, CaPathTest001, TestSize.Level1)
46 {
47     HttpRequestOptions requestOptions;
48 
49     string path = requestOptions.GetCaPath();
50     EXPECT_EQ(path, "");
51 }
52 
53 HWTEST_F(HttpRequestOptionsTest, CaPathTest002, TestSize.Level1)
54 {
55     HttpRequestOptions requestOptions;
56 
57     requestOptions.SetCaPath("");
58     string path = requestOptions.GetCaPath();
59     EXPECT_EQ(path, "");
60 }
61 
62 HWTEST_F(HttpRequestOptionsTest, CaPathTest003, TestSize.Level1)
63 {
64     HttpRequestOptions requestOptions;
65 
66     requestOptions.SetCaPath(OTHER_CA_PATH);
67     string path = requestOptions.GetCaPath();
68     EXPECT_EQ(path, OTHER_CA_PATH);
69 }
70 
71 HWTEST_F(HttpRequestOptionsTest, SetDnsServersTest, TestSize.Level1)
72 {
73     HttpRequestOptions requestOptions;
74 
75     std::vector<std::string> dnsServers = { "8.8.8.8", "8.8.4.4" };
76     requestOptions.SetDnsServers(dnsServers);
77 
78     const std::vector<std::string>& retrievedDnsServers = requestOptions.GetDnsServers();
79     EXPECT_EQ(retrievedDnsServers, dnsServers);
80 }
81 
82 HWTEST_F(HttpRequestOptionsTest, SetDohUrlTest, TestSize.Level1)
83 {
84     HttpRequestOptions requestOptions;
85 
86     std::string dohUrl = "https://example.com/dns-query";
87     requestOptions.SetDohUrl(dohUrl);
88 
89     const std::string& retrievedDohUrl = requestOptions.GetDohUrl();
90     EXPECT_EQ(retrievedDohUrl, dohUrl);
91 }
92 
93 HWTEST_F(HttpRequestOptionsTest, SetRangeNumberTest001, TestSize.Level1)
94 {
95     HttpRequestOptions requestOptions;
96 
97     uint32_t resumeFromNumber = 10;
98     uint32_t resumeToNumber = 20;
99     requestOptions.SetRangeNumber(resumeFromNumber, resumeToNumber);
100 
101     const std::string& rangeString = requestOptions.GetRangeString();
102     std::string expectedRangeString = "10-20";
103     EXPECT_EQ(rangeString, expectedRangeString);
104 }
105 
106 HWTEST_F(HttpRequestOptionsTest, SetRangeNumberTest002, TestSize.Level1)
107 {
108     HttpRequestOptions requestOptions;
109 
110     uint32_t resumeFromNumber = 0;
111     uint32_t resumeToNumber = 20;
112     requestOptions.SetRangeNumber(resumeFromNumber, resumeToNumber);
113 
114     const std::string& rangeString = requestOptions.GetRangeString();
115     std::string expectedRangeString = "-20";
116     EXPECT_EQ(rangeString, expectedRangeString);
117 }
118 
119 HWTEST_F(HttpRequestOptionsTest, SetRangeNumberTest003, TestSize.Level1)
120 {
121     HttpRequestOptions requestOptions;
122 
123     uint32_t resumeFromNumber = 10;
124     uint32_t resumeToNumber = 0;
125     requestOptions.SetRangeNumber(resumeFromNumber, resumeToNumber);
126 
127     const std::string& rangeString = requestOptions.GetRangeString();
128     std::string expectedRangeString = "10-";
129     EXPECT_EQ(rangeString, expectedRangeString);
130 }
131 
132 HWTEST_F(HttpRequestOptionsTest, SetRangeNumberTest004, TestSize.Level1)
133 {
134     HttpRequestOptions requestOptions;
135 
136     uint32_t resumeFromNumber = 0;
137     uint32_t resumeToNumber = 0;
138     requestOptions.SetRangeNumber(resumeFromNumber, resumeToNumber);
139 
140     const std::string& rangeString = requestOptions.GetRangeString();
141     std::string expectedRangeString = "";
142     EXPECT_EQ(rangeString, expectedRangeString);
143 }
144 
145 HWTEST_F(HttpRequestOptionsTest, SetClientCertTest, TestSize.Level1)
146 {
147     HttpRequestOptions requestOptions;
148 
149     std::string cert = "path_to_cert.pem";
150     std::string key = "path_to_key.pem";
151     std::string certType = "PEM";
152     Secure::SecureChar keyPasswd("password");
153 
154     requestOptions.SetClientCert(cert, certType, key, keyPasswd);
155 
156     std::string retrievedCert;
157     std::string retrievedKey;
158     std::string retrievedCertType;
159     Secure::SecureChar retrievedKeyPasswd;
160 
161     requestOptions.GetClientCert(retrievedCert, retrievedCertType, retrievedKey, retrievedKeyPasswd);
162 
163     EXPECT_EQ(retrievedCert, cert);
164     EXPECT_EQ(retrievedKey, key);
165     EXPECT_EQ(retrievedCertType, certType);
166     EXPECT_EQ(strcmp(retrievedKeyPasswd.Data(), keyPasswd.Data()), 0);
167 }
168 
169 HWTEST_F(HttpRequestOptionsTest, AddMultiFormDataTest, TestSize.Level1)
170 {
171     HttpRequestOptions requestOptions;
172     for (int i = 0; i < 10; i++) {
173         MultiFormData multiFormData;
174         multiFormData.name = "name" + std::to_string(i);
175         multiFormData.data = "data" + std::to_string(i);
176         multiFormData.contentType = "contentType" + std::to_string(i);
177         multiFormData.remoteFileName = "remoteFileName" + std::to_string(i);
178         multiFormData.filePath = "filePath" + std::to_string(i);
179         requestOptions.AddMultiFormData(multiFormData);
180     }
181     std::vector<MultiFormData> dataList = requestOptions.GetMultiPartDataList();
182     EXPECT_EQ(dataList.size(), 10);
183     for (int i = 0; i < 10; i++) {
184         MultiFormData data = dataList[i];
185         EXPECT_EQ(data.name, "name" + std::to_string(i));
186         EXPECT_EQ(data.data, "data" + std::to_string(i));
187         EXPECT_EQ(data.contentType, "contentType" + std::to_string(i));
188         EXPECT_EQ(data.filePath, "filePath" + std::to_string(i));
189         EXPECT_EQ(data.remoteFileName, "remoteFileName" + std::to_string(i));
190     }
191 }
192 
193 HWTEST_F(HttpRequestOptionsTest, SetUrlTest, TestSize.Level1)
194 {
195     HttpRequestOptions requestOptions;
196 
197     std::string testValue = "Example";
198     requestOptions.SetUrl(testValue);
199     std::string url = requestOptions.GetUrl();
200     EXPECT_EQ(url, testValue);
201 }
202 
203 HWTEST_F(HttpRequestOptionsTest, SetPrioritylTest, TestSize.Level1)
204 {
205     HttpRequestOptions requestOptions;
206 
207     uint32_t testValue = 2;
208     requestOptions.SetPriority(testValue);
209     uint32_t resultValue = requestOptions.GetPriority();
210     EXPECT_EQ(resultValue, testValue);
211 }
212 
213 HWTEST_F(HttpRequestOptionsTest, SetHttpDataTypeTest, TestSize.Level1)
214 {
215     HttpRequestOptions requestOptions;
216 
217     HttpDataType testValue = HttpDataType::ARRAY_BUFFER;
218     requestOptions.SetHttpDataType(testValue);
219     HttpDataType resultValue = requestOptions.GetHttpDataType();
220     EXPECT_EQ(resultValue, testValue);
221 }
222 
223 HWTEST_F(HttpRequestOptionsTest, SetUsingProtocolTest001, TestSize.Level1)
224 {
225     HttpRequestOptions requestOptions;
226 
227     HttpProtocol testValue = HttpProtocol::HTTP1_1;
228     requestOptions.SetUsingProtocol(testValue);
229     uint32_t resultValue = requestOptions.GetHttpVersion();
230     EXPECT_EQ(resultValue, CURL_HTTP_VERSION_1_1);
231 }
232 
233 HWTEST_F(HttpRequestOptionsTest, SetUsingProtocolTest002, TestSize.Level1)
234 {
235     HttpRequestOptions requestOptions;
236 
237     HttpProtocol testValue = HttpProtocol::HTTP2;
238     requestOptions.SetUsingProtocol(testValue);
239     uint32_t resultValue = requestOptions.GetHttpVersion();
240     EXPECT_EQ(resultValue, CURL_HTTP_VERSION_2_0);
241 }
242 
243 HWTEST_F(HttpRequestOptionsTest, SetUsingProtocolTest003, TestSize.Level1)
244 {
245     HttpRequestOptions requestOptions;
246 
247     HttpProtocol testValue = HttpProtocol::HTTP3;
248     requestOptions.SetUsingProtocol(testValue);
249     uint32_t resultValue = requestOptions.GetHttpVersion();
250     EXPECT_EQ(resultValue, CURL_HTTP_VERSION_3);
251 }
252 
253 HWTEST_F(HttpRequestOptionsTest, SetUsingProtocolTest004, TestSize.Level1)
254 {
255     HttpRequestOptions requestOptions;
256 
257     HttpProtocol testValue = HttpProtocol::HTTP_NONE;
258     requestOptions.SetUsingProtocol(testValue);
259     uint32_t resultValue = requestOptions.GetHttpVersion();
260     EXPECT_EQ(resultValue, CURL_HTTP_VERSION_NONE);
261 }
262 
263 HWTEST_F(HttpRequestOptionsTest, SetMaxLimitTest, TestSize.Level1)
264 {
265     HttpRequestOptions requestOptions;
266 
267     uint32_t testValue = 50;
268     requestOptions.SetMaxLimit(testValue);
269     uint32_t resultValue = requestOptions.GetMaxLimit();
270     EXPECT_EQ(resultValue, testValue);
271 }
272 
273 HWTEST_F(HttpRequestOptionsTest, SetConnectTimeoutTest, TestSize.Level1)
274 {
275     HttpRequestOptions requestOptions;
276 
277     uint32_t testValue = 5000;
278     requestOptions.SetConnectTimeout(testValue);
279     uint32_t resultValue = requestOptions.GetConnectTimeout();
280     EXPECT_EQ(resultValue, testValue);
281 }
282 
283 HWTEST_F(HttpRequestOptionsTest, SetReadTimeoutTest, TestSize.Level1)
284 {
285     HttpRequestOptions requestOptions;
286 
287     uint32_t testValue = 5000;
288     requestOptions.SetReadTimeout(testValue);
289     uint32_t resultValue = requestOptions.GetReadTimeout();
290     EXPECT_EQ(resultValue, testValue);
291 }
292 
293 HWTEST_F(HttpRequestOptionsTest, SetHeaderTest, TestSize.Level1)
294 {
295     HttpRequestOptions requestOptions;
296 
297     int testSize = 10;
298     for (int i = 0; i < testSize; i++) {
299         requestOptions.SetHeader("key" + std::to_string(i), "value" + std::to_string(i));
300     }
301     const std::map<std::string, std::string> header = requestOptions.GetHeader();
302     for (int i = 0; i < testSize; i++) {
303         const std::string& value = header.at("key" + std::to_string(i));
304         EXPECT_EQ(value, "value" + std::to_string(i));
305     }
306 }
307 
308 HWTEST_F(HttpRequestOptionsTest, SetBodyTest, TestSize.Level1)
309 {
310     HttpRequestOptions requestOptions;
311 
312     std::string testValue = "TestBody";
313     requestOptions.SetBody(testValue.data(), testValue.size());
314     std::string resultValue = requestOptions.GetBody();
315     EXPECT_EQ(resultValue, testValue);
316 }
317 
318 HWTEST_F(HttpRequestOptionsTest, SetCertificatePinningTest, TestSize.Level1)
319 {
320     HttpRequestOptions requestOptions;
321     std::string testPIN = "sha256//YhKJKSzoTt2b5FP18fvpHo7fJYqQCjAa3HWY3tvRMwE=;sha256//t62CeU2tQiqkexU74Gxa2eg7fRbEg";
322     requestOptions.SetCertificatePinning(testPIN);
323     std::string resultPIN = requestOptions.GetCertificatePinning();
324     EXPECT_EQ(testPIN, resultPIN);
325 }
326 
327 HWTEST_F(HttpRequestOptionsTest, TlvEncodeDecodeTest001, TestSize.Level1)
328 {
329     DfxMessage msg{};
330     msg.requestBeginTime_ = 0;
331     msg.requestEndTime_ = 1;
332     msg.requestId_ = "1";
333     msg.responseStatusCode_ = 200;
334     msg.responseHttpVersion_ = "1.1";
335     const int bufferMaxSize = 1 * 256 * 1024;
336     void *data = malloc(bufferMaxSize);
337     EXPECT_TRUE(data != nullptr);
338     uint32_t dataSize = 0;
339     auto ret = TlvUtils::Encode(msg, data, dataSize);
340     EXPECT_EQ(ret, TLV_OK);
341     EXPECT_GT(dataSize, 0);
342     DfxMessage result{};
343     ret = TlvUtils::Decode(result, data, dataSize);
344     EXPECT_EQ(ret, TLV_OK);
345     EXPECT_EQ(msg.requestBeginTime_, result.requestBeginTime_);
346     EXPECT_EQ(msg.requestEndTime_, result.requestEndTime_);
347     EXPECT_EQ(msg.requestId_, result.requestId_);
348     EXPECT_EQ(msg.responseStatusCode_, result.responseStatusCode_);
349     EXPECT_EQ(msg.responseHttpVersion_, result.responseHttpVersion_);
350 }
351 } // namespace