1 /*
2 * Copyright (c) 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 <gtest/gtest.h>
17 #include <fstream>
18 #include <sstream>
19
20 #ifdef GTEST_API_
21 #define private public
22 #define protected public
23 #endif
24
25 #include <netdb.h>
26 #include "dns_quality_diag.h"
27 #include "net_handle.h"
28 #include "net_conn_client.h"
29 #include "common_notify_callback_test.h"
30
31 namespace OHOS {
32 namespace nmd {
33 namespace {
34 using namespace testing::ext;
35 const uint32_t MAX_RESULT_SIZE = 32;
36 } // namespace
37
38 class DnsQualityDiagTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42 void SetUp();
43 void TearDown();
44
45 protected:
46 NetsysNative::NetDnsResultReport report;
47 NetsysNative::NetDnsQueryResultReport queryReport;
48 DnsQualityDiag dnsQualityDiag;
49 struct AddrInfo addrinfoIpv4;
50 struct AddrInfo addrinfoIpv6;
51 };
52
SetUpTestCase()53 void DnsQualityDiagTest::SetUpTestCase() {}
54
TearDownTestCase()55 void DnsQualityDiagTest::TearDownTestCase() {}
56
SetUp()57 void DnsQualityDiagTest::SetUp() {}
58
TearDown()59 void DnsQualityDiagTest::TearDown() {}
60
61 HWTEST_F(DnsQualityDiagTest, DnsQualityDiag_ShouldReturnZero_WhenCalled, TestSize.Level0)
62 {
63 EXPECT_EQ(dnsQualityDiag.InitHandler(), 0);
64 }
65
66 HWTEST_F(DnsQualityDiagTest, GetInstanceShouldReturnSingletonInstance, TestSize.Level0)
67 {
68 DnsQualityDiag &instance1 = DnsQualityDiag::GetInstance();
69 DnsQualityDiag &instance2 = DnsQualityDiag::GetInstance();
70 EXPECT_EQ(instance1.report_delay, instance2.report_delay);
71 }
72
73 HWTEST_F(DnsQualityDiagTest, SendHealthReport_ShouldReturnZero_WhenCalled, TestSize.Level0)
74 {
75 NetsysNative::NetDnsHealthReport healthreport;
76 EXPECT_EQ(dnsQualityDiag.SendHealthReport(healthreport), 0);
77 }
78
79 HWTEST_F(DnsQualityDiagTest, ParseReportAddr_ShouldAddIPv4AndIPv6_WhenCalledWithValidAddrInfo, TestSize.Level0)
80 {
81 uint32_t size = 2;
82 addrinfoIpv4.aiFamily = AF_INET;
83 addrinfoIpv6.aiFamily = AF_INET6;
84 struct AddrInfo addrinfo[2] = { addrinfoIpv4, addrinfoIpv6 };
85
86 int32_t returnCode = dnsQualityDiag.ParseReportAddr(size, addrinfo, report);
87
88 EXPECT_EQ(report.addrlist_.size(), 2);
89 EXPECT_EQ(returnCode, 0);
90 }
91
92 HWTEST_F(DnsQualityDiagTest, ParseReportAddr_ShouldNotAddMoreThanMaxSize_WhenCalledWithMoreAddrInfo, TestSize.Level0)
93 {
94 uint32_t size = MAX_RESULT_SIZE + 1;
95 addrinfoIpv4.aiFamily = AF_INET;
96 struct AddrInfo addrinfo[MAX_RESULT_SIZE + 1] = { addrinfoIpv4 };
97
98 int32_t returnCode = dnsQualityDiag.ParseReportAddr(size, addrinfo, report);
99
100 EXPECT_EQ(report.addrlist_.size(), MAX_RESULT_SIZE);
101 EXPECT_EQ(returnCode, 0);
102 }
103
104 HWTEST_F(DnsQualityDiagTest, ReportDnsResult_ShouldReturnZero_WhenCalled_01, TestSize.Level0)
105 {
106 uint16_t netId = 1;
107 uint16_t uid = 1;
108 uint32_t pid = 1;
109 int32_t usedtime = 1;
110 char name[] = "test";
111 uint32_t size = 1;
112 int32_t failreason = 0;
113 QueryParam queryParam;
114 AddrInfo addrinfo;
115 EXPECT_EQ(dnsQualityDiag.ReportDnsResult(netId, uid, pid, usedtime, name, size, failreason, queryParam, &addrinfo),
116 0);
117 }
118
119 HWTEST_F(DnsQualityDiagTest, ReportDnsResult_ShouldReturnZero_WhenCalled_02, TestSize.Level0)
120 {
121 uint16_t netId = 1;
122 uint16_t uid = 1;
123 uint32_t pid = 1;
124 int32_t usedtime = 1;
125 char name[] = "test";
126 uint32_t size = 1;
127 int32_t failreason = 1;
128 QueryParam queryParam;
129 AddrInfo addrinfo;
130 EXPECT_EQ(dnsQualityDiag.ReportDnsResult(netId, uid, pid, usedtime, name, size, failreason, queryParam, &addrinfo),
131 0);
132 }
133
134 HWTEST_F(DnsQualityDiagTest, ReportDnsResult_ShouldIgnore_WhenQueryTypeIsOne, TestSize.Level0)
135 {
136 uint16_t netId = 1;
137 uint16_t uid = 1;
138 uint32_t pid = 1;
139 int32_t usedtime = 100;
140 char name[] = "test";
141 uint32_t size = 10;
142 int32_t failreason = 0;
143 QueryParam queryParam;
144 queryParam.type = 1;
145 AddrInfo addrinfo;
146
147 int32_t result =
148 dnsQualityDiag.ReportDnsResult(netId, uid, pid, usedtime, name, size, failreason, queryParam, &addrinfo);
149 EXPECT_EQ(result, 0);
150 }
151
152 HWTEST_F(DnsQualityDiagTest, ReportDnsQueryResult_ShouldReturnZero_WhenCalled_01, TestSize.Level0)
153 {
154 struct PostDnsQueryParam queryParam;
155 struct FamilyQueryInfoExt ipv4Info;
156 ipv4Info.retCode = 0;
157 ipv4Info.isNoAnswer = 0;
158 ipv4Info.cname = 0;
159 struct FamilyQueryInfoExt ipv6Info;
160 ipv6Info.retCode = 0;
161 ipv6Info.isNoAnswer = 0;
162 ipv6Info.cname = 0;
163 queryParam.netId = 100;
164 queryParam.uid = 10000;
165 queryParam.pid = 5896;
166 queryParam.addrSize = 0;
167 struct DnsProcessInfoExt processInfo;
168 processInfo.queryTime = 0;
169 processInfo.retCode = 0;
170 processInfo.firstQueryEndDuration = 10;
171 processInfo.firstQueryEnd2AppDuration = 10;
172 processInfo.firstReturnType = 1;
173 processInfo.isFromCache = 0;
174 processInfo.sourceFrom = 2;
175 processInfo.ipv4QueryInfo = ipv4Info;
176 processInfo.ipv6QueryInfo = ipv6Info;
177 AddrInfo addrinfo;
178 queryParam.processInfo = processInfo;
179 int32_t result =
180 dnsQualityDiag.ReportDnsQueryResult(queryParam, &addrinfo, 0);
181 EXPECT_EQ(result, 0);
182 }
183
184 HWTEST_F(DnsQualityDiagTest, ReportDnsQueryAbnormal_ShouldReturnZero_WhenCalled_01, TestSize.Level0)
185 {
186 struct PostDnsQueryParam queryParam;
187 struct FamilyQueryInfoExt ipv4Info;
188 ipv4Info.retCode = 0;
189 ipv4Info.isNoAnswer = 0;
190 ipv4Info.cname = 0;
191 struct FamilyQueryInfoExt ipv6Info;
192 ipv6Info.retCode = 0;
193 ipv6Info.isNoAnswer = 0;
194 ipv6Info.cname = 0;
195 queryParam.netId = 100;
196 queryParam.uid = 10000;
197 queryParam.pid = 5896;
198 queryParam.addrSize = 0;
199 struct DnsProcessInfoExt processInfo;
200 processInfo.queryTime = 0;
201 processInfo.retCode = 0;
202 processInfo.firstQueryEndDuration = 10;
203 processInfo.firstQueryEnd2AppDuration = 10;
204 processInfo.firstReturnType = 1;
205 processInfo.isFromCache = 0;
206 processInfo.sourceFrom = 2;
207 processInfo.ipv4QueryInfo = ipv4Info;
208 processInfo.ipv6QueryInfo = ipv6Info;
209 AddrInfo addrinfo;
210 queryParam.processInfo = processInfo;
211 int32_t result =
212 dnsQualityDiag.ReportDnsQueryAbnormal(1, queryParam, &addrinfo);
213 EXPECT_EQ(result, 0);
214 }
215
216 HWTEST_F(DnsQualityDiagTest, Handle_dns_abnormal_AddIPv4AndIPv6_WhenCalledWithValidAddrInfo, TestSize.Level0)
217 {
218 std::shared_ptr<DnsAbnormalInfo> abnormalInfo =
219 std::make_shared<DnsAbnormalInfo>();
220 NetsysNative::NetDnsQueryResultReport queryReport;
221 abnormalInfo->eventfailcause = 1;
222 abnormalInfo->report = queryReport;
223 EXPECT_EQ(dnsQualityDiag.handle_dns_abnormal(abnormalInfo), 0);
224 }
225
226 HWTEST_F(DnsQualityDiagTest, Handle_dns_abnormal_AddIPv4AndIPv6_WhenCalledWithNullptr, TestSize.Level0)
227 {
228 std::shared_ptr<DnsAbnormalInfo> abnormalInfo = nullptr;
229 EXPECT_EQ(dnsQualityDiag.handle_dns_abnormal(abnormalInfo), 0);
230 }
231
232 HWTEST_F(DnsQualityDiagTest, ParseDnsQueryReportAddr_AddIPv4AndIPv6_WhenCalledWithValidAddrInfo, TestSize.Level0)
233 {
234 uint32_t size = 2;
235 addrinfoIpv4.aiFamily = AF_INET;
236 addrinfoIpv6.aiFamily = AF_INET6;
237 struct AddrInfo addrinfo[2] = { addrinfoIpv4, addrinfoIpv6 };
238
239 int32_t returnCode = dnsQualityDiag.ParseDnsQueryReportAddr(size, addrinfo, queryReport);
240
241 EXPECT_EQ(queryReport.addrlist_.size(), 2);
242 EXPECT_EQ(returnCode, 0);
243 }
244
245 HWTEST_F(DnsQualityDiagTest, ParseDnsQueryReportAddr_NotAddMoreThanMaxSize_WhenCalledWithMoreAddrInfo, TestSize.Level0)
246 {
247 uint32_t size = MAX_RESULT_SIZE + 1;
248 addrinfoIpv4.aiFamily = AF_INET;
249 struct AddrInfo addrinfo[MAX_RESULT_SIZE + 1] = { addrinfoIpv4 };
250
251 int32_t returnCode = dnsQualityDiag.ParseDnsQueryReportAddr(size, addrinfo, queryReport);
252
253 EXPECT_EQ(queryReport.addrlist_.size(), MAX_RESULT_SIZE);
254 EXPECT_EQ(returnCode, 0);
255 }
256
257 HWTEST_F(DnsQualityDiagTest, RegisterResultListener_ShouldReturnZero_WhenCalled, TestSize.Level0)
258 {
259 sptr<NetsysNative::INetDnsResultCallback> callback = nullptr;
260 uint32_t timeStep = 1;
261 EXPECT_EQ(dnsQualityDiag.RegisterResultListener(callback, timeStep), 0);
262 }
263
264 HWTEST_F(DnsQualityDiagTest, UnregisterResultListener_ShouldReturnZero_WhenCalled, TestSize.Level0)
265 {
266 sptr<NetsysNative::INetDnsResultCallback> callback = nullptr;
267 EXPECT_EQ(dnsQualityDiag.UnregisterResultListener(callback), 0);
268 }
269
270 HWTEST_F(DnsQualityDiagTest, UnregisterResultListener_Unreg_After_Reg, TestSize.Level0)
271 {
272 sptr<NetsysNative::INetDnsResultCallback> callback = new NetsysNative::DnsResultCallbackTest();
273 uint32_t timeStep = 1;
274 EXPECT_EQ(dnsQualityDiag.RegisterResultListener(callback, timeStep), 0);
275
276 EXPECT_EQ(dnsQualityDiag.UnregisterResultListener(callback), 0);
277 }
278
279 HWTEST_F(DnsQualityDiagTest, RegisterHealthListener_ShouldReturnZero_WhenCalled, TestSize.Level0)
280 {
281 sptr<NetsysNative::INetDnsHealthCallback> callback;
282 EXPECT_EQ(dnsQualityDiag.RegisterHealthListener(callback), 0);
283 }
284
285 HWTEST_F(DnsQualityDiagTest, UnregisterHealthListener_ShouldReturnZero_WhenCalled, TestSize.Level0)
286 {
287 sptr<NetsysNative::INetDnsHealthCallback> callback;
288 EXPECT_EQ(dnsQualityDiag.UnregisterHealthListener(callback), 0);
289 }
290
291 HWTEST_F(DnsQualityDiagTest, SetLoopDelay_ShouldReturnZero_WhenCalled, TestSize.Level0)
292 {
293 int32_t delay = 1;
294 EXPECT_EQ(dnsQualityDiag.SetLoopDelay(delay), 0);
295 }
296
297 HWTEST_F(DnsQualityDiagTest, query_default_host_ShouldReturnZero_WhenCalled, TestSize.Level0)
298 {
299 EXPECT_EQ(dnsQualityDiag.query_default_host(), 0);
300 }
301
302 HWTEST_F(DnsQualityDiagTest, handle_dns_loop_ShouldReturnZero_WhenCalled_01, TestSize.Level0)
303 {
304 dnsQualityDiag.handler_started = false;
305 EXPECT_EQ(dnsQualityDiag.handle_dns_loop(), 0);
306 }
307
308 HWTEST_F(DnsQualityDiagTest, handle_dns_loop_ShouldReturnZero_WhenCalled_02, TestSize.Level0)
309 {
310 dnsQualityDiag.handler_started = true;
311 EXPECT_EQ(dnsQualityDiag.handle_dns_loop(), 0);
312 }
313
314 HWTEST_F(DnsQualityDiagTest, handle_dns_fail_ShouldReturnZero_WhenCalled_01, TestSize.Level0)
315 {
316 dnsQualityDiag.handler_started = false;
317 EXPECT_EQ(dnsQualityDiag.handle_dns_fail(), 0);
318 }
319
320 HWTEST_F(DnsQualityDiagTest, handle_dns_fail_ShouldReturnZero_WhenCalled_02, TestSize.Level0)
321 {
322 dnsQualityDiag.handler_started = true;
323 EXPECT_EQ(dnsQualityDiag.handle_dns_fail(), 0);
324 }
325
326 HWTEST_F(DnsQualityDiagTest, send_dns_report_ShouldReturnZero_WhenCalled_01, TestSize.Level0)
327 {
328 dnsQualityDiag.handler_started = false;
329 EXPECT_EQ(dnsQualityDiag.send_dns_report(), 0);
330 }
331
332 HWTEST_F(DnsQualityDiagTest, send_dns_report_ShouldReturnZero_WhenCalled_02, TestSize.Level0)
333 {
334 dnsQualityDiag.handler_started = true;
335 EXPECT_EQ(dnsQualityDiag.send_dns_report(), 0);
336 }
337
338 HWTEST_F(DnsQualityDiagTest, send_dns_report_ShouldReturnZero_WhenCalled_03, TestSize.Level0)
339 {
340 std::shared_ptr<NetsysNative::NetDnsResultReport> report;
341 report = std::make_shared<NetsysNative::NetDnsResultReport>();
342 EXPECT_EQ(dnsQualityDiag.add_dns_report(report), 0);
343 EXPECT_TRUE(dnsQualityDiag.report_.size() > 0);
344
345 dnsQualityDiag.handler_started = true;
346 EXPECT_EQ(dnsQualityDiag.send_dns_report(), 0);
347 EXPECT_EQ(dnsQualityDiag.report_.size(), 0);
348 }
349
350 HWTEST_F(DnsQualityDiagTest, add_dns_report_ShouldReturnZero_WhenCalled_01, TestSize.Level0)
351 {
352 std::shared_ptr<NetsysNative::NetDnsResultReport> report;
353 report = std::make_shared<NetsysNative::NetDnsResultReport>();
354 EXPECT_EQ(dnsQualityDiag.add_dns_report(report), 0);
355 EXPECT_EQ(dnsQualityDiag.report_.size(), 1);
356 }
357
358 HWTEST_F(DnsQualityDiagTest, add_dns_report_ShouldReturnZero_WhenCalled_02, TestSize.Level0)
359 {
360 std::shared_ptr<NetsysNative::NetDnsResultReport> report = nullptr;
361 EXPECT_EQ(dnsQualityDiag.add_dns_report(report), 0);
362 }
363
364 HWTEST_F(DnsQualityDiagTest, add_dns_report_ShouldNotAddReport_WhenReportListIsFull, TestSize.Level0)
365 {
366 for (int i = 0; i < MAX_RESULT_SIZE; i++) {
367 std::shared_ptr<NetsysNative::NetDnsResultReport> report = std::make_shared<NetsysNative::NetDnsResultReport>();
368 dnsQualityDiag.add_dns_report(report);
369 }
370 std::shared_ptr<NetsysNative::NetDnsResultReport> report = std::make_shared<NetsysNative::NetDnsResultReport>();
371 int32_t result = dnsQualityDiag.add_dns_report(report);
372 ASSERT_EQ(result, 0);
373 ASSERT_EQ(dnsQualityDiag.report_.size(), MAX_RESULT_SIZE);
374
375 uint16_t netId = 1;
376 uint16_t uid = 1;
377 uint32_t pid = 1;
378 int32_t usedtime = 1;
379 char name[] = "test";
380 uint32_t size = 1;
381 int32_t failreason = 1;
382 QueryParam queryParam;
383 AddrInfo addrinfo;
384 EXPECT_EQ(dnsQualityDiag.ReportDnsResult(netId, uid, pid, usedtime, name, size, failreason, queryParam, &addrinfo),
385 0);
386 }
387
388 HWTEST_F(DnsQualityDiagTest, add_dns_query_report_ShouldReturnZero_WhenCalled_01, TestSize.Level0)
389 {
390 std::shared_ptr<NetsysNative::NetDnsQueryResultReport> queryReport;
391 queryReport = std::make_shared<NetsysNative::NetDnsQueryResultReport>();
392 EXPECT_EQ(dnsQualityDiag.add_dns_query_report(queryReport), 0);
393 EXPECT_EQ(dnsQualityDiag.dnsQueryReport_.size(), 1);
394 }
395
396 HWTEST_F(DnsQualityDiagTest, add_dns_query_report_ShouldReturnZero_WhenCalled_02, TestSize.Level0)
397 {
398 std::shared_ptr<NetsysNative::NetDnsQueryResultReport> queryReport = nullptr;
399 EXPECT_EQ(dnsQualityDiag.add_dns_query_report(queryReport), 0);
400 }
401
402 HWTEST_F(DnsQualityDiagTest, add_dns_query_report_ShouldNotAddReport_WhenReportListIsFull, TestSize.Level0)
403 {
404 for (int i = 0; i < MAX_RESULT_SIZE; i++) {
405 std::shared_ptr<NetsysNative::NetDnsQueryResultReport> report =
406 std::make_shared<NetsysNative::NetDnsQueryResultReport>();
407 dnsQualityDiag.add_dns_query_report(report);
408 }
409 std::shared_ptr<NetsysNative::NetDnsQueryResultReport> report =
410 std::make_shared<NetsysNative::NetDnsQueryResultReport>();
411 int32_t result = dnsQualityDiag.add_dns_query_report(report);
412 ASSERT_EQ(result, 0);
413 ASSERT_EQ(dnsQualityDiag.dnsQueryReport_.size(), MAX_RESULT_SIZE);
414 }
415
416 HWTEST_F(DnsQualityDiagTest, load_query_addr_ShouldReturnZero_WhenCalled, TestSize.Level0)
417 {
418 const char *defaultAddr = "test";
419 EXPECT_EQ(dnsQualityDiag.load_query_addr(defaultAddr), 0);
420 }
421
422 HWTEST_F(DnsQualityDiagTest, HandleEvent_ShouldReturnZero_WhenCalled_01, TestSize.Level0)
423 {
424 dnsQualityDiag.handler_started = false;
425 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get();
426 EXPECT_EQ(dnsQualityDiag.HandleEvent(event), 0);
427 }
428
429 HWTEST_F(DnsQualityDiagTest, HandleEvent_ShouldReturnZero_WhenCalled_02, TestSize.Level0)
430 {
431 dnsQualityDiag.handler_started = true;
432 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(DnsQualityEventHandler::MSG_DNS_MONITOR_LOOP);
433 EXPECT_EQ(dnsQualityDiag.HandleEvent(event), 0);
434 }
435
436 HWTEST_F(DnsQualityDiagTest, HandleEvent_ShouldReturnZero_WhenCalled_03, TestSize.Level0)
437 {
438 dnsQualityDiag.handler_started = true;
439 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(DnsQualityEventHandler::MSG_DNS_QUERY_FAIL);
440 EXPECT_EQ(dnsQualityDiag.HandleEvent(event), 0);
441 }
442
443 HWTEST_F(DnsQualityDiagTest, HandleEvent_ShouldReturnZero_WhenCalled_04, TestSize.Level0)
444 {
445 dnsQualityDiag.handler_started = true;
446 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(DnsQualityEventHandler::MSG_DNS_REPORT_LOOP);
447 EXPECT_EQ(dnsQualityDiag.HandleEvent(event), 0);
448 }
449
450 HWTEST_F(DnsQualityDiagTest, HandleEvent_ShouldReturnZero_WhenCalled_05, TestSize.Level0)
451 {
452 dnsQualityDiag.handler_started = true;
453 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(DnsQualityEventHandler::MSG_DNS_NEW_REPORT);
454 EXPECT_EQ(dnsQualityDiag.HandleEvent(event), 0);
455 }
456
457 } // namespace nmd
458 } // namespace OHOS
459