• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2023-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 <cstring>
17 #include "gtest/gtest.h"
18 #include "http_client_request.h"
19 #include "http_client_constant.h"
20 #include "netstack_log.h"
21 
22 using namespace OHOS::NetStack::HttpClient;
23 
24 class HttpClientRequestTest : public testing::Test {
25 public:
SetUpTestCase()26     static void SetUpTestCase() {}
27 
TearDownTestCase()28     static void TearDownTestCase() {}
29 
SetUp()30     virtual void SetUp() {}
31 
TearDown()32     virtual void TearDown() {}
33 };
34 
35 namespace {
36 using namespace std;
37 using namespace testing::ext;
38 constexpr char OTHER_CA_PATH[] = "/etc/ssl/certs/other.pem";
39 static constexpr const uint32_t HTTP_DEFAULT_PRIORITY = 500;
40 
41 HWTEST_F(HttpClientRequestTest, GetCaPathTest001, TestSize.Level1)
42 {
43     HttpClientRequest req;
44 
45     string path = req.GetCaPath();
46     EXPECT_EQ(path, "");
47 }
48 
49 HWTEST_F(HttpClientRequestTest, SetCaPathTest001, TestSize.Level1)
50 {
51     HttpClientRequest req;
52 
53     req.SetCaPath("");
54     string path = req.GetCaPath();
55 
56     EXPECT_EQ(path, "");
57 }
58 
59 HWTEST_F(HttpClientRequestTest, SetCaPathTest002, TestSize.Level1)
60 {
61     HttpClientRequest req;
62 
63     req.SetCaPath(OTHER_CA_PATH);
64     string path = req.GetCaPath();
65 
66     EXPECT_EQ(path, OTHER_CA_PATH);
67 }
68 
69 HWTEST_F(HttpClientRequestTest, GetURLTest001, TestSize.Level1)
70 {
71     HttpClientRequest req;
72 
73     string urlTest = req.GetURL();
74     EXPECT_EQ(urlTest, "");
75 }
76 
77 HWTEST_F(HttpClientRequestTest, SetURLTest001, TestSize.Level1)
78 {
79     HttpClientRequest req;
80     std::string url = "http://www.httpbin.org/get";
81     req.SetURL(url);
82     string urlTest = req.GetURL();
83     EXPECT_EQ(urlTest, url);
84 }
85 
86 HWTEST_F(HttpClientRequestTest, GetMethodTest001, TestSize.Level1)
87 {
88     HttpClientRequest req;
89 
90     string method = req.GetMethod();
91     EXPECT_EQ(method, HttpConstant::HTTP_METHOD_GET);
92 }
93 
94 HWTEST_F(HttpClientRequestTest, SetMethodTest001, TestSize.Level1)
95 {
96     HttpClientRequest req;
97     req.SetMethod("abc");
98     string method = req.GetMethod();
99     NETSTACK_LOGI("SetMethodTest001 GetMethod = %{public}s", method.c_str());
100     EXPECT_EQ(method, HttpConstant::HTTP_METHOD_GET);
101 }
102 
103 HWTEST_F(HttpClientRequestTest, SetMethodTest002, TestSize.Level1)
104 {
105     HttpClientRequest req;
106     req.SetMethod(HttpConstant::HTTP_METHOD_POST);
107     string method = req.GetMethod();
108     EXPECT_EQ(method, HttpConstant::HTTP_METHOD_POST);
109 }
110 
111 HWTEST_F(HttpClientRequestTest, GetBodyTest001, TestSize.Level1)
112 {
113     HttpClientRequest req;
114     std::string body = "";
115 
116     string bodyTest = req.GetBody();
117     EXPECT_EQ(bodyTest, body);
118 }
119 
120 HWTEST_F(HttpClientRequestTest, SetBodyTest001, TestSize.Level1)
121 {
122     HttpClientRequest req;
123     std::string body = "hello world";
124 
125     req.SetBody(body.data(), body.length());
126     string bodyTest = req.GetBody();
127 
128     EXPECT_EQ(bodyTest, body);
129 }
130 
131 HWTEST_F(HttpClientRequestTest, GetTimeoutTest001, TestSize.Level1)
132 {
133     HttpClientRequest req;
134 
135     int timeouTest = req.GetTimeout();
136     EXPECT_EQ(timeouTest, HttpConstant::DEFAULT_READ_TIMEOUT);
137 }
138 
139 HWTEST_F(HttpClientRequestTest, SetTimeoutTest001, TestSize.Level1)
140 {
141     HttpClientRequest req;
142     req.SetTimeout(1000);
143     int timeouTest = req.GetTimeout();
144     EXPECT_EQ(timeouTest, 1000);
145 }
146 
147 HWTEST_F(HttpClientRequestTest, GetConnectTimeoutTest001, TestSize.Level1)
148 {
149     HttpClientRequest req;
150 
151     int timeouTest = req.GetConnectTimeout();
152     EXPECT_EQ(timeouTest, HttpConstant::DEFAULT_CONNECT_TIMEOUT);
153 }
154 
155 HWTEST_F(HttpClientRequestTest, SetConnectTimeoutTest001, TestSize.Level1)
156 {
157     HttpClientRequest req;
158     req.SetConnectTimeout(1000);
159     int timeouTest = req.GetConnectTimeout();
160     EXPECT_EQ(timeouTest, 1000);
161 }
162 
163 HWTEST_F(HttpClientRequestTest, GetHttpProtocolTest001, TestSize.Level1)
164 {
165     HttpClientRequest req;
166 
167     int timeouTest = req.GetHttpProtocol();
168     EXPECT_EQ(timeouTest, HttpProtocol::HTTP_NONE);
169 }
170 
171 HWTEST_F(HttpClientRequestTest, SetHttpProtocolTest001, TestSize.Level1)
172 {
173     HttpClientRequest req;
174     req.SetHttpProtocol(HttpProtocol::HTTP1_1);
175     int protocolTest = req.GetHttpProtocol();
176     EXPECT_EQ(protocolTest, HttpProtocol::HTTP1_1);
177 }
178 
179 HWTEST_F(HttpClientRequestTest, GetHttpProxyTest001, TestSize.Level1)
180 {
181     HttpClientRequest req;
182 
183     const OHOS::NetStack::HttpClient::HttpProxy &proxyType = req.GetHttpProxy();
184     EXPECT_EQ(proxyType.host, "");
185 }
186 
187 HWTEST_F(HttpClientRequestTest, SetHttpProxyTest001, TestSize.Level1)
188 {
189     HttpClientRequest req;
190     HttpProxy proxy;
191     proxy.host = "192.168.147.60";
192     req.SetHttpProxy(proxy);
193     const OHOS::NetStack::HttpClient::HttpProxy &proxyType = req.GetHttpProxy();
194     EXPECT_EQ(proxyType.host, proxy.host);
195 }
196 
197 HWTEST_F(HttpClientRequestTest, GetHttpProxyTypeTest001, TestSize.Level1)
198 {
199     HttpClientRequest req;
200 
201     int proxyType = req.GetHttpProxyType();
202     EXPECT_EQ(proxyType, HttpProxyType::NOT_USE);
203 }
204 
205 HWTEST_F(HttpClientRequestTest, SetHttpProxyTypeTest001, TestSize.Level1)
206 {
207     HttpClientRequest req;
208     req.SetHttpProxyType(HttpProxyType::USE_SPECIFIED);
209     int proxyType = req.GetHttpProxyType();
210     EXPECT_EQ(proxyType, HttpProxyType::USE_SPECIFIED);
211 }
212 
213 HWTEST_F(HttpClientRequestTest, GetPriorityTest001, TestSize.Level1)
214 {
215     HttpClientRequest req;
216 
217     uint32_t priorityTest = req.GetPriority();
218     EXPECT_EQ(priorityTest, HTTP_DEFAULT_PRIORITY);
219 }
220 
221 HWTEST_F(HttpClientRequestTest, SetPriorityTest001, TestSize.Level1)
222 {
223     HttpClientRequest req;
224     req.SetPriority(0);
225     uint32_t priorityTest = req.GetPriority();
226     EXPECT_EQ(priorityTest, HTTP_DEFAULT_PRIORITY);
227 }
228 
229 HWTEST_F(HttpClientRequestTest, SetPriorityTest002, TestSize.Level1)
230 {
231     HttpClientRequest req;
232 
233     req.SetPriority(1001);
234     uint32_t priorityTest = req.GetPriority();
235 
236     EXPECT_EQ(priorityTest, HTTP_DEFAULT_PRIORITY);
237 }
238 
239 HWTEST_F(HttpClientRequestTest, SetPriorityTest003, TestSize.Level1)
240 {
241     HttpClientRequest req;
242 
243     req.SetPriority(500);
244     uint32_t priorityTest = req.GetPriority();
245 
246     EXPECT_EQ(priorityTest, HTTP_DEFAULT_PRIORITY);
247 }
248 
249 HWTEST_F(HttpClientRequestTest, GetHeaderTest001, TestSize.Level1)
250 {
251     HttpClientRequest req;
252 
253     std::map<std::string, std::string> headers = req.GetHeaders();
254     EXPECT_EQ(headers.empty(), true);
255 }
256 
257 HWTEST_F(HttpClientRequestTest, SetHeaderTest001, TestSize.Level1)
258 {
259     HttpClientRequest req;
260 
261     std::string header = "application/json";
262     req.SetHeader("content-type", "application/json");
263     std::map<std::string, std::string> headers = req.GetHeaders();
264     EXPECT_EQ(headers["content-type"], header);
265 }
266 
267 HWTEST_F(HttpClientRequestTest, MethodForGetTest001, TestSize.Level1)
268 {
269     HttpClientRequest req;
270     bool method = req.MethodForGet("");
271     EXPECT_EQ(method, false);
272 }
273 
274 HWTEST_F(HttpClientRequestTest, MethodForGetTest002, TestSize.Level1)
275 {
276     HttpClientRequest req;
277     bool method = req.MethodForGet("GET");
278     EXPECT_EQ(method, true);
279 }
280 
281 HWTEST_F(HttpClientRequestTest, MethodForPostTest001, TestSize.Level1)
282 {
283     HttpClientRequest req;
284     bool method = req.MethodForPost("");
285     EXPECT_EQ(method, false);
286 }
287 
288 HWTEST_F(HttpClientRequestTest, MethodForPostTest002, TestSize.Level1)
289 {
290     HttpClientRequest req;
291     bool method = req.MethodForPost("POST");
292     EXPECT_EQ(method, true);
293 }
294 
295 HWTEST_F(HttpClientRequestTest, GetResumeFromTest001, TestSize.Level1)
296 {
297     HttpClientRequest req;
298 
299     int64_t resumeFrom = req.GetResumeFrom();
300     EXPECT_EQ(resumeFrom, 0);
301 }
302 
303 HWTEST_F(HttpClientRequestTest, SetResumeFromTest001, TestSize.Level1)
304 {
305     HttpClientRequest req;
306 
307     req.SetResumeFrom(1000);
308     int64_t resumeFrom = req.GetResumeFrom();
309     EXPECT_EQ(resumeFrom, 1000);
310 }
311 
312 HWTEST_F(HttpClientRequestTest, SetResumeFromTest002, TestSize.Level1)
313 {
314     HttpClientRequest req;
315 
316     req.SetResumeFrom(-10);
317     int64_t resumeFrom = req.GetResumeFrom();
318     EXPECT_EQ(resumeFrom, 0);
319 }
320 
321 HWTEST_F(HttpClientRequestTest, SetResumeFromTest003, TestSize.Level1)
322 {
323     HttpClientRequest req;
324 
325     req.SetResumeFrom(MAX_RESUM_NUMBER + 5);
326     int64_t resumeFrom = req.GetResumeFrom();
327     EXPECT_EQ(resumeFrom, 0);
328 }
329 
330 HWTEST_F(HttpClientRequestTest, GetResumeToTest001, TestSize.Level1)
331 {
332     HttpClientRequest req;
333 
334     int64_t resumeFrom = req.GetResumeTo();
335     EXPECT_EQ(resumeFrom, 0);
336 }
337 
338 HWTEST_F(HttpClientRequestTest, SetResumeToTest001, TestSize.Level1)
339 {
340     HttpClientRequest req;
341 
342     req.SetResumeTo(1000);
343     int64_t resumeTo = req.GetResumeTo();
344     EXPECT_EQ(resumeTo, 1000);
345 }
346 
347 HWTEST_F(HttpClientRequestTest, SetResumeToTest002, TestSize.Level1)
348 {
349     HttpClientRequest req;
350 
351     req.SetResumeTo(-10);
352     int64_t resumeTo = req.GetResumeTo();
353     EXPECT_EQ(resumeTo, 0);
354 }
355 
356 HWTEST_F(HttpClientRequestTest, SetResumeToTest003, TestSize.Level1)
357 {
358     HttpClientRequest req;
359 
360     req.SetResumeTo(MAX_RESUM_NUMBER + 5);
361     int64_t resumeTo = req.GetResumeTo();
362     EXPECT_EQ(resumeTo, 0);
363 }
364 
365 HWTEST_F(HttpClientRequestTest, SetAddressFamilyTest001, TestSize.Level1)
366 {
367     HttpClientRequest req;
368 
369     req.SetAddressFamily("DEFAULT");
370     std::string addressFamily = req.GetAddressFamily();
371     EXPECT_EQ(addressFamily, "DEFAULT");
372 }
373 
374 HWTEST_F(HttpClientRequestTest, GetAddressFamilyTest001, TestSize.Level1)
375 {
376     HttpClientRequest req;
377 
378     std::string addressFamily = req.GetAddressFamily();
379     EXPECT_EQ(addressFamily.empty(), true);
380 }
381 
382 HWTEST_F(HttpClientRequestTest, GetClientCertTest001, TestSize.Level1)
383 {
384     HttpClientRequest req;
385 
386     HttpClientCert clientCert = req.GetClientCert();
387     EXPECT_EQ(clientCert.certPath, "");
388 }
389 
390 HWTEST_F(HttpClientRequestTest, SetClientCertTest001, TestSize.Level1)
391 {
392     HttpClientRequest req;
393 
394     HttpClientCert clientCert;
395     clientCert.certPath = "/path/to/client.pem";
396     clientCert.certType = "PEM";
397     clientCert.keyPath = "/path/to/client.key";
398     clientCert.keyPassword = "passwordToKey";
399     req.SetClientCert(clientCert);
400     HttpClientCert client = req.GetClientCert();
401     EXPECT_EQ(client.keyPassword, "passwordToKey");
402 }
403 
404 HWTEST_F(HttpClientRequestTest, SetClientCertTest002, TestSize.Level1)
405 {
406     HttpClientRequest req;
407 
408     HttpClientCert clientCert;
409     clientCert.certPath = "/path/to/client.pem";
410     req.SetClientCert(clientCert);
411     HttpClientCert client = req.GetClientCert();
412     EXPECT_EQ(client.keyPassword, "");
413 }
414 } // namespace
415