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, CaDataTest001, TestSize.Level1) 72 { 73 HttpRequestOptions requestOptions; 74 75 string data = requestOptions.GetCaData(); 76 EXPECT_EQ(data, ""); 77 } 78 79 HWTEST_F(HttpRequestOptionsTest, CaDataTest002, TestSize.Level1) 80 { 81 HttpRequestOptions requestOptions; 82 83 requestOptions.SetCaData("abc"); 84 string data = requestOptions.GetCaData(); 85 EXPECT_EQ(data, "abc"); 86 } 87 88 HWTEST_F(HttpRequestOptionsTest, SetDnsServersTest, TestSize.Level1) 89 { 90 HttpRequestOptions requestOptions; 91 92 std::vector<std::string> dnsServers = { "8.8.8.8", "8.8.4.4" }; 93 requestOptions.SetDnsServers(dnsServers); 94 95 const std::vector<std::string>& retrievedDnsServers = requestOptions.GetDnsServers(); 96 EXPECT_EQ(retrievedDnsServers, dnsServers); 97 } 98 99 HWTEST_F(HttpRequestOptionsTest, SetDohUrlTest, TestSize.Level1) 100 { 101 HttpRequestOptions requestOptions; 102 103 std::string dohUrl = "https://example.com/dns-query"; 104 requestOptions.SetDohUrl(dohUrl); 105 106 const std::string& retrievedDohUrl = requestOptions.GetDohUrl(); 107 EXPECT_EQ(retrievedDohUrl, dohUrl); 108 } 109 110 HWTEST_F(HttpRequestOptionsTest, SetRangeNumberTest001, TestSize.Level1) 111 { 112 HttpRequestOptions requestOptions; 113 114 uint32_t resumeFromNumber = 10; 115 uint32_t resumeToNumber = 20; 116 requestOptions.SetRangeNumber(resumeFromNumber, resumeToNumber); 117 118 const std::string& rangeString = requestOptions.GetRangeString(); 119 std::string expectedRangeString = "10-20"; 120 EXPECT_EQ(rangeString, expectedRangeString); 121 } 122 123 HWTEST_F(HttpRequestOptionsTest, SetRangeNumberTest002, TestSize.Level1) 124 { 125 HttpRequestOptions requestOptions; 126 127 uint32_t resumeFromNumber = 0; 128 uint32_t resumeToNumber = 20; 129 requestOptions.SetRangeNumber(resumeFromNumber, resumeToNumber); 130 131 const std::string& rangeString = requestOptions.GetRangeString(); 132 std::string expectedRangeString = "-20"; 133 EXPECT_EQ(rangeString, expectedRangeString); 134 } 135 136 HWTEST_F(HttpRequestOptionsTest, SetRangeNumberTest003, TestSize.Level1) 137 { 138 HttpRequestOptions requestOptions; 139 140 uint32_t resumeFromNumber = 10; 141 uint32_t resumeToNumber = 0; 142 requestOptions.SetRangeNumber(resumeFromNumber, resumeToNumber); 143 144 const std::string& rangeString = requestOptions.GetRangeString(); 145 std::string expectedRangeString = "10-"; 146 EXPECT_EQ(rangeString, expectedRangeString); 147 } 148 149 HWTEST_F(HttpRequestOptionsTest, SetRangeNumberTest004, TestSize.Level1) 150 { 151 HttpRequestOptions requestOptions; 152 153 uint32_t resumeFromNumber = 0; 154 uint32_t resumeToNumber = 0; 155 requestOptions.SetRangeNumber(resumeFromNumber, resumeToNumber); 156 157 const std::string& rangeString = requestOptions.GetRangeString(); 158 std::string expectedRangeString = ""; 159 EXPECT_EQ(rangeString, expectedRangeString); 160 } 161 162 HWTEST_F(HttpRequestOptionsTest, SetClientCertTest, TestSize.Level1) 163 { 164 HttpRequestOptions requestOptions; 165 166 std::string cert = "path_to_cert.pem"; 167 std::string key = "path_to_key.pem"; 168 std::string certType = "PEM"; 169 Secure::SecureChar keyPasswd("password"); 170 171 requestOptions.SetClientCert(cert, certType, key, keyPasswd); 172 173 std::string retrievedCert; 174 std::string retrievedKey; 175 std::string retrievedCertType; 176 Secure::SecureChar retrievedKeyPasswd; 177 178 requestOptions.GetClientCert(retrievedCert, retrievedCertType, retrievedKey, retrievedKeyPasswd); 179 180 EXPECT_EQ(retrievedCert, cert); 181 EXPECT_EQ(retrievedKey, key); 182 EXPECT_EQ(retrievedCertType, certType); 183 EXPECT_EQ(strcmp(retrievedKeyPasswd.Data(), keyPasswd.Data()), 0); 184 } 185 186 HWTEST_F(HttpRequestOptionsTest, AddMultiFormDataTest, TestSize.Level1) 187 { 188 HttpRequestOptions requestOptions; 189 for (int i = 0; i < 10; i++) { 190 MultiFormData multiFormData; 191 multiFormData.name = "name" + std::to_string(i); 192 multiFormData.data = "data" + std::to_string(i); 193 multiFormData.contentType = "contentType" + std::to_string(i); 194 multiFormData.remoteFileName = "remoteFileName" + std::to_string(i); 195 multiFormData.filePath = "filePath" + std::to_string(i); 196 requestOptions.AddMultiFormData(multiFormData); 197 } 198 std::vector<MultiFormData> dataList = requestOptions.GetMultiPartDataList(); 199 EXPECT_EQ(dataList.size(), 10); 200 for (int i = 0; i < 10; i++) { 201 MultiFormData data = dataList[i]; 202 EXPECT_EQ(data.name, "name" + std::to_string(i)); 203 EXPECT_EQ(data.data, "data" + std::to_string(i)); 204 EXPECT_EQ(data.contentType, "contentType" + std::to_string(i)); 205 EXPECT_EQ(data.filePath, "filePath" + std::to_string(i)); 206 EXPECT_EQ(data.remoteFileName, "remoteFileName" + std::to_string(i)); 207 } 208 } 209 210 HWTEST_F(HttpRequestOptionsTest, SetUrlTest, TestSize.Level1) 211 { 212 HttpRequestOptions requestOptions; 213 214 std::string testValue = "Example"; 215 requestOptions.SetUrl(testValue); 216 std::string url = requestOptions.GetUrl(); 217 EXPECT_EQ(url, testValue); 218 } 219 220 HWTEST_F(HttpRequestOptionsTest, SetPrioritylTest, TestSize.Level1) 221 { 222 HttpRequestOptions requestOptions; 223 224 uint32_t testValue = 2; 225 requestOptions.SetPriority(testValue); 226 uint32_t resultValue = requestOptions.GetPriority(); 227 EXPECT_EQ(resultValue, testValue); 228 } 229 230 HWTEST_F(HttpRequestOptionsTest, SetHttpDataTypeTest, TestSize.Level1) 231 { 232 HttpRequestOptions requestOptions; 233 234 HttpDataType testValue = HttpDataType::ARRAY_BUFFER; 235 requestOptions.SetHttpDataType(testValue); 236 HttpDataType resultValue = requestOptions.GetHttpDataType(); 237 EXPECT_EQ(resultValue, testValue); 238 } 239 240 HWTEST_F(HttpRequestOptionsTest, SetUsingProtocolTest001, TestSize.Level1) 241 { 242 HttpRequestOptions requestOptions; 243 244 HttpProtocol testValue = HttpProtocol::HTTP1_1; 245 requestOptions.SetUsingProtocol(testValue); 246 uint32_t resultValue = requestOptions.GetHttpVersion(); 247 EXPECT_EQ(resultValue, CURL_HTTP_VERSION_1_1); 248 } 249 250 HWTEST_F(HttpRequestOptionsTest, SetUsingProtocolTest002, TestSize.Level1) 251 { 252 HttpRequestOptions requestOptions; 253 254 HttpProtocol testValue = HttpProtocol::HTTP2; 255 requestOptions.SetUsingProtocol(testValue); 256 uint32_t resultValue = requestOptions.GetHttpVersion(); 257 EXPECT_EQ(resultValue, CURL_HTTP_VERSION_2_0); 258 } 259 260 HWTEST_F(HttpRequestOptionsTest, SetUsingProtocolTest003, TestSize.Level1) 261 { 262 HttpRequestOptions requestOptions; 263 264 HttpProtocol testValue = HttpProtocol::HTTP3; 265 requestOptions.SetUsingProtocol(testValue); 266 uint32_t resultValue = requestOptions.GetHttpVersion(); 267 EXPECT_EQ(resultValue, CURL_HTTP_VERSION_3); 268 } 269 270 HWTEST_F(HttpRequestOptionsTest, SetUsingProtocolTest004, TestSize.Level1) 271 { 272 HttpRequestOptions requestOptions; 273 274 HttpProtocol testValue = HttpProtocol::HTTP_NONE; 275 requestOptions.SetUsingProtocol(testValue); 276 uint32_t resultValue = requestOptions.GetHttpVersion(); 277 EXPECT_EQ(resultValue, CURL_HTTP_VERSION_NONE); 278 } 279 280 HWTEST_F(HttpRequestOptionsTest, SetMaxLimitTest, TestSize.Level1) 281 { 282 HttpRequestOptions requestOptions; 283 284 uint32_t testValue = 50; 285 requestOptions.SetMaxLimit(testValue); 286 uint32_t resultValue = requestOptions.GetMaxLimit(); 287 EXPECT_EQ(resultValue, testValue); 288 } 289 290 HWTEST_F(HttpRequestOptionsTest, SetConnectTimeoutTest, TestSize.Level1) 291 { 292 HttpRequestOptions requestOptions; 293 294 uint32_t testValue = 5000; 295 requestOptions.SetConnectTimeout(testValue); 296 uint32_t resultValue = requestOptions.GetConnectTimeout(); 297 EXPECT_EQ(resultValue, testValue); 298 } 299 300 HWTEST_F(HttpRequestOptionsTest, SetReadTimeoutTest, TestSize.Level1) 301 { 302 HttpRequestOptions requestOptions; 303 304 uint32_t testValue = 5000; 305 requestOptions.SetReadTimeout(testValue); 306 uint32_t resultValue = requestOptions.GetReadTimeout(); 307 EXPECT_EQ(resultValue, testValue); 308 } 309 310 HWTEST_F(HttpRequestOptionsTest, SetHeaderTest, TestSize.Level1) 311 { 312 HttpRequestOptions requestOptions; 313 314 int testSize = 10; 315 for (int i = 0; i < testSize; i++) { 316 requestOptions.SetHeader("key" + std::to_string(i), "value" + std::to_string(i)); 317 } 318 const std::map<std::string, std::string> header = requestOptions.GetHeader(); 319 for (int i = 0; i < testSize; i++) { 320 const std::string& value = header.at("key" + std::to_string(i)); 321 EXPECT_EQ(value, "value" + std::to_string(i)); 322 } 323 } 324 325 HWTEST_F(HttpRequestOptionsTest, SetBodyTest, TestSize.Level1) 326 { 327 HttpRequestOptions requestOptions; 328 329 std::string testValue = "TestBody"; 330 requestOptions.SetBody(testValue.data(), testValue.size()); 331 std::string resultValue = requestOptions.GetBody(); 332 EXPECT_EQ(resultValue, testValue); 333 } 334 335 HWTEST_F(HttpRequestOptionsTest, SetCertificatePinningTest, TestSize.Level1) 336 { 337 HttpRequestOptions requestOptions; 338 std::string testPIN = "sha256//YhKJKSzoTt2b5FP18fvpHo7fJYqQCjAa3HWY3tvRMwE=;sha256//t62CeU2tQiqkexU74Gxa2eg7fRbEg"; 339 requestOptions.SetCertificatePinning(testPIN); 340 std::string resultPIN = requestOptions.GetCertificatePinning(); 341 EXPECT_EQ(testPIN, resultPIN); 342 } 343 } // namespace