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 <algorithm>
17 #include <cstring>
18 #include <gtest/gtest.h>
19 #include <iostream>
20
21 #ifdef GTEST_API_
22 #define private public
23 #define protected public
24 #endif
25
26 #include "net_conn_constants.h"
27 #include "net_manager_constants.h"
28 #include "net_stats_constants.h"
29 #include "netsys_controller.h"
30 #include "netsys_controller_service_impl.h"
31
32 namespace OHOS {
33 namespace NetManagerStandard {
34 namespace {
35 using namespace testing::ext;
36 } // namespace
37
38 class NetsysControllerServiceImplTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41
42 static void TearDownTestCase();
43
44 void SetUp();
45
46 void TearDown();
47
48 static inline std::shared_ptr<NetsysControllerServiceImpl> instance_ = nullptr;
49 };
50
SetUpTestCase()51 void NetsysControllerServiceImplTest::SetUpTestCase()
52 {
53 instance_ = std::make_shared<NetsysControllerServiceImpl>();
54 if (instance_) {
55 instance_->mockNetsysClient_.mockApi_.clear();
56 instance_->mockNetsysClient_.mockApi_.insert(MOCK_NETWORKCREATEPHYSICAL_API);
57 instance_->mockNetsysClient_.mockApi_.insert(MOCK_NETWORKDESTROY_API);
58 instance_->mockNetsysClient_.mockApi_.insert(MOCK_NETWORKADDINTERFACE_API);
59 instance_->mockNetsysClient_.mockApi_.insert(MOCK_NETWORKREMOVEINTERFACE_API);
60 instance_->mockNetsysClient_.mockApi_.insert(MOCK_NETWORKADDROUTE_API);
61 instance_->mockNetsysClient_.mockApi_.insert(MOCK_NETWORKREMOVEROUTE_API);
62 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SETINTERFACEDOWN_API);
63 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SETINTERFACEUP_API);
64 instance_->mockNetsysClient_.mockApi_.insert(MOCK_INTERFACEGETMTU_API);
65 instance_->mockNetsysClient_.mockApi_.insert(MOCK_INTERFACESETMTU_API);
66 instance_->mockNetsysClient_.mockApi_.insert(MOCK_INTERFACEADDADDRESS_API);
67 instance_->mockNetsysClient_.mockApi_.insert(MOCK_INTERFACEDELADDRESS_API);
68 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SETRESOLVERCONFIG_API);
69 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETRESOLVERICONFIG_API);
70 instance_->mockNetsysClient_.mockApi_.insert(MOCK_CREATENETWORKCACHE_API);
71 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SETDEFAULTNETWORK_API);
72 instance_->mockNetsysClient_.mockApi_.insert(MOCK_CLEARDEFAULTNETWORK_API);
73 instance_->mockNetsysClient_.mockApi_.insert(MOCK_STARTDHCPCLIENT_API);
74 instance_->mockNetsysClient_.mockApi_.insert(MOCK_STOPDHCPCLIENT_API);
75 instance_->mockNetsysClient_.mockApi_.insert(MOCK_REGISTERNOTIFYCALLBACK_API);
76 instance_->mockNetsysClient_.mockApi_.insert(MOCK_STARTDHCPSERVICE_API);
77 instance_->mockNetsysClient_.mockApi_.insert(MOCK_STOPDHCPSERVICE_API);
78 }
79 }
80
TearDownTestCase()81 void NetsysControllerServiceImplTest::TearDownTestCase() {}
82
SetUp()83 void NetsysControllerServiceImplTest::SetUp() {}
84
TearDown()85 void NetsysControllerServiceImplTest::TearDown() {}
86
87 HWTEST_F(NetsysControllerServiceImplTest, NoRegisterMockApi, TestSize.Level1)
88 {
89 uint16_t baseTimeoutMsec = 0;
90 uint8_t retryCount = 0;
91 std::string testName = "eth0";
92 std::vector<std::string> servers;
93 std::vector<std::string> domains;
94 sptr<NetsysControllerCallback> callback = nullptr;
95
96 auto ret = instance_->NetworkCreatePhysical(0, 0);
97 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
98
99 ret = instance_->NetworkDestroy(0);
100 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
101
102 ret = instance_->NetworkAddInterface(0, testName);
103 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
104
105 ret = instance_->NetworkRemoveInterface(0, testName);
106 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
107
108 ret = instance_->NetworkAddRoute(0, testName, testName, testName);
109 EXPECT_EQ(ret, -1);
110
111 ret = instance_->NetworkRemoveRoute(0, testName, testName, testName);
112 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
113
114 ret = instance_->SetInterfaceDown(testName);
115 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
116
117 ret = instance_->SetInterfaceUp(testName);
118 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
119
120 ret = instance_->GetInterfaceMtu(testName);
121 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
122
123 ret = instance_->SetInterfaceMtu(testName, 1);
124 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
125
126 ret = instance_->AddInterfaceAddress(testName, testName, 1);
127 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
128
129 ret = instance_->DelInterfaceAddress(testName, testName, 1);
130 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
131
132 ret = instance_->SetResolverConfig(0, 0, 0, servers, domains);
133 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
134
135 ret = instance_->GetResolverConfig(0, servers, domains, baseTimeoutMsec, retryCount);
136 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
137
138 ret = instance_->RegisterCallback(callback);
139 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
140 }
141
142 HWTEST_F(NetsysControllerServiceImplTest, RunRegisterMockApi, TestSize.Level1)
143 {
144 std::string testName = "wlan0";
145
146 auto ret = instance_->GetCellularRxBytes();
147 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
148
149 instance_->ClearInterfaceAddrs(testName);
150 ret = instance_->GetCellularTxBytes();
151 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
152
153 ret = instance_->GetAllRxBytes();
154 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
155
156 ret = instance_->GetAllTxBytes();
157 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
158
159 ret = instance_->GetUidRxBytes(20010038);
160 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
161
162 ret = instance_->GetUidTxBytes(20010038);
163 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
164
165 ret = instance_->GetIfaceRxBytes(testName);
166 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
167
168 ret = instance_->GetIfaceTxBytes(testName);
169 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
170
171 ret = instance_->GetIfaceRxPackets(testName);
172 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
173
174 ret = instance_->GetIfaceTxPackets(testName);
175 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
176
177 ret = instance_->CreateNetworkCache(0);
178 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
179
180 ret = instance_->SetDefaultNetWork(0);
181 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
182
183 ret = instance_->ClearDefaultNetWorkNetId();
184 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
185
186 ret = instance_->StartDhcpClient(testName, false);
187 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
188
189 ret = instance_->StopDhcpClient(testName, false);
190 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
191
192 ret = instance_->StartDhcpService(testName, testName);
193 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
194
195 ret = instance_->StopDhcpService(testName);
196 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
197
198 auto list = instance_->InterfaceGetList();
199 EXPECT_GT(list.size(), static_cast<uint32_t>(0));
200
201 list = instance_->UidGetList();
202 EXPECT_EQ(list.size(), static_cast<uint32_t>(0));
203 }
204
205 HWTEST_F(NetsysControllerServiceImplTest, ServiceImplTest, TestSize.Level1)
206 {
207 std::vector<UidRange> uidRanges;
208 UidRange uidRang(1, 2);
209 uidRanges.emplace_back(uidRang);
210 int32_t ifaceFd = 5;
211 std::string ipAddr = "172.17.5.245";
212 NetsysNotifyCallback Callback;
213 Callback.NetsysResponseInterfaceAdd = nullptr;
214 Callback.NetsysResponseInterfaceRemoved = nullptr;
215
216 auto ret = instance_->NetworkCreateVirtual(5, false);
217 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
218
219 ret = instance_->NetworkAddUids(5, uidRanges);
220 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
221
222 ret = instance_->NetworkDelUids(5, uidRanges);
223 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
224
225 auto ret32 = instance_->BindSocket(1, 2);
226 EXPECT_EQ(ret32, NetManagerStandard::NETMANAGER_SUCCESS);
227
228 ret32 = instance_->RegisterNetsysNotifyCallback(Callback);
229 EXPECT_EQ(ret32, NetManagerStandard::NETMANAGER_SUCCESS);
230
231 ret32 = instance_->BindNetworkServiceVpn(5);
232 EXPECT_EQ(ret32, NetsysContrlResultCode::NETSYS_ERR_VPN);
233
234 ifreq ifRequest;
235 ret32 = instance_->EnableVirtualNetIfaceCard(5, ifRequest, ifaceFd);
236 EXPECT_EQ(ret32, NetsysContrlResultCode::NETSYS_ERR_VPN);
237
238 ret32 = instance_->SetIpAddress(5, ipAddr, 23, ifRequest);
239 EXPECT_EQ(ret32, NetsysContrlResultCode::NETSYS_ERR_VPN);
240
241 ret32 = instance_->SetBlocking(5, false);
242 EXPECT_EQ(ret32, NetManagerStandard::NETMANAGER_SUCCESS);
243 }
244
245 HWTEST_F(NetsysControllerServiceImplTest, SetInternetPermission, TestSize.Level1)
246 {
247 uint32_t uid = 0;
248 uint8_t allow = 0;
249
250 auto ret = instance_->SetInternetPermission(uid, allow);
251 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
252 }
253
254 } // namespace NetManagerStandard
255 } // namespace OHOS
256