1 /*
2 * Copyright (c) 2022 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 <gtest/gtest.h>
17
18 #ifdef GTEST_API_
19 #define private public
20 #define protected public
21 #endif
22
23 #include "dns_config_client.h"
24 #include "dns_param_cache.h"
25 #include "netnative_log_wrapper.h"
26
27 namespace OHOS {
28 namespace NetsysNative {
29 using namespace testing::ext;
30 using namespace OHOS::nmd;
31 class DNSParamCacheTest : public testing::Test {
32 public:
33 static void SetUpTestCase();
34 static void TearDownTestCase();
35 void SetUp();
36 void TearDown();
37 };
38
SetUpTestCase()39 void DNSParamCacheTest::SetUpTestCase() {}
40
TearDownTestCase()41 void DNSParamCacheTest::TearDownTestCase() {}
42
SetUp()43 void DNSParamCacheTest::SetUp() {}
44
TearDown()45 void DNSParamCacheTest::TearDown() {}
46
47 HWTEST_F(DNSParamCacheTest, SetResolverConfigTest001, TestSize.Level1)
48 {
49 NETNATIVE_LOGI("SetResolverConfigTest001 enter");
50 DnsParamCache dnsParCache;
51 std::vector<std::string> servers;
52 std::vector<std::string> domains;
53 servers.resize(MAX_SERVER_NUM + 1);
54 uint16_t netId = 1;
55 uint16_t baseTimeoutMsec = 0;
56 uint8_t retryCount = 0;
57 int32_t ret = dnsParCache.SetResolverConfig(netId, baseTimeoutMsec, retryCount, servers, domains);
58 EXPECT_EQ(ret, -ENOENT);
59 }
60
61 HWTEST_F(DNSParamCacheTest, SetResolverConfigTest002, TestSize.Level1)
62 {
63 NETNATIVE_LOGI("SetResolverConfigTest002 enter");
64 DnsParamCache dnsParCache;
65 std::vector<std::string> servers;
66 std::vector<std::string> domains;
67 servers.resize(MAX_SERVER_NUM + 1);
68 std::string hostName = "hoseName";
69 AddrInfo addrInfo;
70 for (size_t i = 0; i < MAX_SERVER_NUM; i++) {
71 dnsParCache.CreateCacheForNet(i + 1);
72 dnsParCache.SetDnsCache(i, hostName.append(std::to_string(i)), addrInfo);
73 servers.emplace_back(hostName);
74 }
75 uint16_t netId = 1;
76 uint16_t baseTimeoutMsec = 0;
77 uint8_t retryCount = 0;
78 int32_t ret = dnsParCache.SetResolverConfig(netId, baseTimeoutMsec, retryCount, servers, domains);
79 EXPECT_EQ(ret, 0);
80 }
81
82 HWTEST_F(DNSParamCacheTest, SetResolverConfigTest003, TestSize.Level1)
83 {
84 NETNATIVE_LOGI("SetResolverConfigTest003 enter");
85 DnsParamCache dnsParCache;
86 std::vector<std::string> servers;
87 std::vector<std::string> domains;
88 servers.resize(MAX_SERVER_NUM + 1);
89 uint16_t netId = 1;
90 std::string hostName = "hoseName";
91 dnsParCache.GetDnsCache(netId, hostName);
92 AddrInfo addrInfo;
93 addrInfo.aiFlags = 100;
94 for (size_t i = 0; i < MAX_SERVER_NUM; i++) {
95 dnsParCache.CreateCacheForNet(i);
96 dnsParCache.SetDnsCache(i, hostName.append(std::to_string(i)), addrInfo);
97 servers.emplace_back(hostName.append(std::to_string(i)));
98 }
99
100 uint16_t baseTimeoutMsec = 100;
101 uint8_t retryCount = 2;
102 int32_t ret = dnsParCache.SetResolverConfig(netId, baseTimeoutMsec, retryCount, servers, domains);
103 EXPECT_EQ(ret, 0);
104 netId = 100;
105 ret = dnsParCache.GetResolverConfig(netId, servers, domains, baseTimeoutMsec, retryCount);
106 EXPECT_EQ(ret, -ENOENT);
107 netId = 1;
108 ret = dnsParCache.GetResolverConfig(netId, servers, domains, baseTimeoutMsec, retryCount);
109 EXPECT_EQ(ret, 0);
110 std::string info;
111 dnsParCache.GetDumpInfo(info);
112 }
113
114 HWTEST_F(DNSParamCacheTest, CreateCacheForNetTest, TestSize.Level1)
115 {
116 NETNATIVE_LOGI("CreateCacheForNetTest enter");
117 DnsParamCache dnsParCache;
118 uint16_t netId = 1;
119 dnsParCache.SetDefaultNetwork(netId);
120 int32_t ret = dnsParCache.CreateCacheForNet(netId);
121 EXPECT_EQ(ret, 0);
122 ret = dnsParCache.CreateCacheForNet(netId);
123 EXPECT_EQ(ret, -EEXIST);
124 netId = 0;
125 std::string hostName = "hostName";
126 dnsParCache.SetCacheDelayed(netId, hostName);
127 netId = 2;
128 dnsParCache.SetCacheDelayed(netId, hostName);
129 }
130
131 HWTEST_F(DNSParamCacheTest, DestroyNetworkCacheTest, TestSize.Level1)
132 {
133 NETNATIVE_LOGI("DestroyNetworkCacheTest enter");
134 DnsParamCache dnsParCache;
135 uint16_t netId = 1;
136 int32_t ret = dnsParCache.DestroyNetworkCache(netId);
137 EXPECT_EQ(ret, -ENOENT);
138 dnsParCache.SetDefaultNetwork(netId);
139 dnsParCache.CreateCacheForNet(netId);
140 ret = dnsParCache.DestroyNetworkCache(netId);
141 EXPECT_EQ(ret, 0);
142 }
143
144 HWTEST_F(DNSParamCacheTest, EnableIpv6Test01, TestSize.Level1)
145 {
146 DnsParamCache dnsParCache;
147 uint16_t netId = 1;
148 dnsParCache.EnableIpv6(netId);
149 EXPECT_FALSE(dnsParCache.IsIpv6Enable(netId));
150 }
151
152 HWTEST_F(DNSParamCacheTest, IsIpv6EnableTest01, TestSize.Level1)
153 {
154 DnsParamCache dnsParCache;
155 uint16_t netId = 0;
156 EXPECT_TRUE(netId == dnsParCache.defaultNetId_);
157
158 bool ret = dnsParCache.IsIpv6Enable(netId);
159 EXPECT_FALSE(ret);
160 }
161
162 HWTEST_F(DNSParamCacheTest, GetResolverConfigTest05, TestSize.Level1)
163 {
164 DnsParamCache dnsParCache;
165 std::vector<std::string> servers;
166 std::vector<std::string> domains;
167 servers.resize(MAX_SERVER_NUM + 1);
168 uint16_t netId = 0;
169 std::string hostName = "hoseName";
170 dnsParCache.GetDnsCache(netId, hostName);
171 AddrInfo addrInfo;
172 addrInfo.aiFlags = 100;
173 for (size_t i = 0; i < MAX_SERVER_NUM; i++) {
174 dnsParCache.CreateCacheForNet(i);
175 dnsParCache.SetDnsCache(i, hostName.append(std::to_string(i)), addrInfo);
176 servers.emplace_back(hostName.append(std::to_string(i)));
177 }
178
179 uint16_t baseTimeoutMsec = 100;
180 uint8_t retryCount = 2;
181 int32_t ret = dnsParCache.GetResolverConfig(netId, servers, domains, baseTimeoutMsec, retryCount);
182 EXPECT_TRUE(netId == dnsParCache.defaultNetId_);
183
184 uint32_t uid = 1;
185 ret = dnsParCache.GetResolverConfig(netId, uid, servers, domains, baseTimeoutMsec, retryCount);
186 EXPECT_TRUE(netId == dnsParCache.defaultNetId_);
187 ret = dnsParCache.GetResolverConfig(netId, uid, servers, domains, baseTimeoutMsec, retryCount);
188 EXPECT_EQ(ret, 0);
189 }
190
191 HWTEST_F(DNSParamCacheTest, GetDnsCacheTest01, TestSize.Level1)
192 {
193 DnsParamCache dnsParCache;
194 uint16_t netId = 0;
195 std::string hostName = "";
196 auto ret = dnsParCache.GetDnsCache(netId, hostName);
197 EXPECT_TRUE(netId == dnsParCache.defaultNetId_);
198 }
199
200 HWTEST_F(DNSParamCacheTest, GetUserDefinedServerFlagTest001, TestSize.Level1)
201 {
202 NETNATIVE_LOGI("GetUserDefinedServerFlagTest001 enter");
203 DnsParamCache dnsParCache;
204 std::vector<NetManagerStandard::UidRange> uidRanges;
205 NetManagerStandard::UidRange uidrange1(10000, 20000);
206 uidRanges.push_back(uidrange1);
207 uint16_t netId = 0;
208 bool flag = false;
209 dnsParCache.SetDefaultNetwork(netId);
210 dnsParCache.CreateCacheForNet(netId);
211 int32_t ret = dnsParCache.GetUserDefinedServerFlag(netId, flag, 10001);
212 EXPECT_EQ(ret, 0);
213 }
214
215 HWTEST_F(DNSParamCacheTest, GetUserDefinedServerFlagTest002, TestSize.Level1)
216 {
217 NETNATIVE_LOGI("GetUserDefinedServerFlagTest002 enter");
218 DnsParamCache dnsParCache;
219 uint16_t netId = 0;
220 bool flag = false;
221 dnsParCache.SetDefaultNetwork(netId);
222 dnsParCache.CreateCacheForNet(netId);
223 int32_t ret = dnsParCache.GetUserDefinedServerFlag(netId, flag);
224 EXPECT_EQ(ret, 0);
225 }
226
227 HWTEST_F(DNSParamCacheTest, GetUserDefinedServerFlagTest003, TestSize.Level1)
228 {
229 NETNATIVE_LOGI("GetUserDefinedServerFlagTest003 enter");
230 DnsParamCache dnsParCache;
231 std::vector<NetManagerStandard::UidRange> uidRanges;
232 NetManagerStandard::UidRange uidrange1(10000, 20000);
233 uidRanges.push_back(uidrange1);
234 uint16_t netId = 1;
235 bool flag = false;
236 dnsParCache.SetDefaultNetwork(netId);
237 dnsParCache.CreateCacheForNet(netId);
238 int32_t ret = dnsParCache.GetUserDefinedServerFlag(netId, flag, 9999);
239 EXPECT_EQ(ret, 0);
240 }
241
242 HWTEST_F(DNSParamCacheTest, GetUserDefinedServerFlagTest004, TestSize.Level1)
243 {
244 NETNATIVE_LOGI("GetUserDefinedServerFlagTest004 enter");
245 DnsParamCache dnsParCache;
246 std::vector<NetManagerStandard::UidRange> uidRanges;
247 NetManagerStandard::UidRange uidrange1(10000, 20000);
248 uidRanges.push_back(uidrange1);
249 uint16_t netId = 0;
250 dnsParCache.SetDefaultNetwork(1);
251 dnsParCache.CreateCacheForNet(1);
252 bool flag = false;
253 int32_t ret = dnsParCache.GetUserDefinedServerFlag(netId, flag, 9999);
254 EXPECT_EQ(ret, 0);
255 }
256
257 HWTEST_F(DNSParamCacheTest, GetUserDefinedServerFlagTest005, TestSize.Level1)
258 {
259 NETNATIVE_LOGI("GetUserDefinedServerFlagTest005 enter");
260 DnsParamCache dnsParCache;
261 std::vector<NetManagerStandard::UidRange> uidRanges;
262 NetManagerStandard::UidRange uidrange1(10000, 20000);
263 uidRanges.push_back(uidrange1);
264 uint16_t netId = 1;
265 bool flag = false;
266 int32_t ret = dnsParCache.GetUserDefinedServerFlag(netId, flag, 9999);
267 EXPECT_EQ(ret, -ENOENT);
268 }
269
270 HWTEST_F(DNSParamCacheTest, GetUserDefinedServerFlagTest006, TestSize.Level1)
271 {
272 NETNATIVE_LOGI("GetUserDefinedServerFlagTest006 enter");
273 DnsParamCache dnsParCache;
274 uint16_t netId = 0;
275 bool flag = false;
276 dnsParCache.SetDefaultNetwork(1);
277 dnsParCache.CreateCacheForNet(1);
278 int32_t ret = dnsParCache.GetUserDefinedServerFlag(netId, flag);
279 EXPECT_EQ(ret, 0);
280 }
281
282 HWTEST_F(DNSParamCacheTest, GetUserDefinedServerFlagTest007, TestSize.Level1)
283 {
284 NETNATIVE_LOGI("GetUserDefinedServerFlagTest007 enter");
285 DnsParamCache dnsParCache;
286 uint16_t netId = 1;
287 bool flag = false;
288 int32_t ret = dnsParCache.GetUserDefinedServerFlag(netId, flag);
289 EXPECT_EQ(ret, -ENOENT);
290 }
291
292 HWTEST_F(DNSParamCacheTest, IsUseVpnDnsTest001, TestSize.Level1)
293 {
294 NETNATIVE_LOGI("IsUseVpnDnsTest007 enter");
295 DnsParamCache dnsParCache;
296 bool ret = dnsParCache.IsUseVpnDns(0);
297 EXPECT_FALSE(ret);
298 }
299
300 HWTEST_F(DNSParamCacheTest, CreateCacheForNetTest001, TestSize.Level1)
301 {
302 NETNATIVE_LOGI("CreateCacheForNetTest001 enter");
303 DnsParamCache dnsParCache;
304 uint16_t netId = 1;
305
306 dnsParCache.SetDefaultNetwork(netId);
307
308 int32_t ret = dnsParCache.CreateCacheForNet(netId, false);
309 EXPECT_EQ(ret, 0);
310
311 uint16_t netId2 = 2;
312 ret = dnsParCache.CreateCacheForNet(netId2, false);
313 EXPECT_EQ(ret, 0);
314
315 auto it1 = dnsParCache.serverConfigMap_.find(netId);
316 auto it2 = dnsParCache.serverConfigMap_.find(netId2);
317 EXPECT_NE(it1, dnsParCache.serverConfigMap_.end());
318 EXPECT_NE(it2, dnsParCache.serverConfigMap_.end());
319
320 uint16_t vpnNetId = 3;
321 ret = dnsParCache.CreateCacheForNet(vpnNetId, true);
322 EXPECT_EQ(ret, 0);
323
324 auto it3 = dnsParCache.serverConfigMap_.find(vpnNetId);
325 EXPECT_NE(it3, dnsParCache.serverConfigMap_.end());
326 }
327
328 HWTEST_F(DNSParamCacheTest, DestroyNetworkCacheTest001, TestSize.Level1)
329 {
330 NETNATIVE_LOGI("DestroyNetworkCacheTest001 enter");
331 DnsParamCache dnsParCache;
332 uint16_t netId = 1;
333
334 dnsParCache.SetDefaultNetwork(netId);
335 dnsParCache.CreateCacheForNet(netId);
336
337 int32_t ret = dnsParCache.DestroyNetworkCache(netId, false);
338 EXPECT_EQ(ret, 0);
339
340 uint16_t netId2 = 2;
341 ret = dnsParCache.DestroyNetworkCache(netId2, false);
342 EXPECT_EQ(ret, -2);
343 }
344
345 HWTEST_F(DNSParamCacheTest, SetUserDefinedServerFlagTest, TestSize.Level1)
346 {
347 NETNATIVE_LOGI("CreateCacheForNetTest enter");
348 DnsParamCache dnsParCache;
349 uint16_t netId = 1;
350 int32_t ret = dnsParCache.SetUserDefinedServerFlag(netId, true);
351 EXPECT_EQ(ret, -2);
352 }
353
354 HWTEST_F(DNSParamCacheTest, FlushDnsCacheTest, TestSize.Level1)
355 {
356 NETNATIVE_LOGI("FlushDnsCacheTest enter");
357 DnsParamCache dnsParCache;
358 uint16_t netId = 1;
359 int32_t ret = dnsParCache.FlushDnsCache(netId);
360 EXPECT_EQ(ret, -2);
361 }
362
363 HWTEST_F(DNSParamCacheTest, FlushDnsCacheTest002, TestSize.Level1)
364 {
365 NETNATIVE_LOGI("FlushDnsCacheTest enter");
366 DnsParamCache dnsParCache;
367 uint16_t netId = 1;
368 dnsParCache.defaultNetId_ = netId;
369 dnsParCache.CreateCacheForNet(netId);
370 int32_t ret = dnsParCache.FlushDnsCache(netId);
371 EXPECT_EQ(ret, 0);
372 }
373
374 HWTEST_F(DNSParamCacheTest, FlushDnsCacheTest003, TestSize.Level1)
375 {
376 NETNATIVE_LOGI("FlushDnsCacheTest enter");
377 DnsParamCache dnsParCache;
378 uint16_t netId = 0;
379 dnsParCache.defaultNetId_ = 1;
380 dnsParCache.CreateCacheForNet(dnsParCache.defaultNetId_);
381 int32_t ret = dnsParCache.FlushDnsCache(netId);
382 EXPECT_EQ(ret, 0);
383 }
384 } // namespace NetsysNative
385 } // namespace OHOS
386