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 } // namespace
296