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 <gtest/gtest.h>
17 
18 #include "accesstoken_kit.h"
19 #include "extended_vpn_ctl.h"
20 #include "nativetoken_kit.h"
21 #include "token_setproc.h"
22 
23 #ifdef GTEST_API_
24 #define private public
25 #define protected public
26 #endif
27 
28 #include "net_manager_constants.h"
29 #include "networkvpn_service.h"
30 #include "vpn_event_callback_stub.h"
31 #include "system_ability_definition.h"
32 #ifdef SUPPORT_SYSVPN
33 #include "ipsecvpn_config.h"
34 #endif // SUPPORT_SYSVPN
35 
36 namespace OHOS {
37 namespace NetManagerStandard {
38 namespace {
39 using namespace testing::ext;
40 constexpr const char *NET_ACTIVATE_WORK_THREAD = "VPN_CALLBACK_WORK_THREAD";
41 class VpnEventTestCallback : public VpnEventCallbackStub {
42 public:
OnVpnStateChanged(const bool & isConnected)43     void OnVpnStateChanged(const bool &isConnected) override{};
OnVpnMultiUserSetUp()44     void OnVpnMultiUserSetUp() override{};
45 };
46 } // namespace
47 
48 class NetworkVpnServiceTest : public testing::Test {
49 public:
50     static void SetUpTestCase();
51     static void TearDownTestCase();
52     void SetUp();
53     void TearDown();
54 #ifdef SUPPORT_SYSVPN
55     void AddSysVpnConfig();
56     void DeleteSysVpnConfig();
57     void GetSysVpnConfigList();
58     void GetSysVpnConfig();
59     void GetConnectedSysVpnConfig();
60 #endif // SUPPORT_SYSVPN
61     static inline auto instance_ = &NetworkVpnService::GetInstance();
62     static inline sptr<IVpnEventCallback> eventCallback_ = nullptr;
63 };
64 
SetUpTestCase()65 void NetworkVpnServiceTest::SetUpTestCase()
66 {
67     instance_->OnStart();
68     eventCallback_ = new (std::nothrow) VpnEventTestCallback();
69     ASSERT_NE(eventCallback_, nullptr);
70 }
71 
TearDownTestCase()72 void NetworkVpnServiceTest::TearDownTestCase()
73 {
74     instance_->OnStop();
75 }
76 
SetUp()77 void NetworkVpnServiceTest::SetUp() {}
78 
TearDown()79 void NetworkVpnServiceTest::TearDown() {}
80 
81 #ifdef SUPPORT_SYSVPN
AddSysVpnConfig()82 void NetworkVpnServiceTest::AddSysVpnConfig() {}
83 
DeleteSysVpnConfig()84 void NetworkVpnServiceTest::DeleteSysVpnConfig() {}
85 
GetSysVpnConfigList()86 void NetworkVpnServiceTest::GetSysVpnConfigList() {}
87 
GetSysVpnConfig()88 void NetworkVpnServiceTest::GetSysVpnConfig() {}
89 
GetConnectedSysVpnConfig()90 void NetworkVpnServiceTest::GetConnectedSysVpnConfig() {}
91 #endif // SUPPORT_SYSVPN
92 
93 HWTEST_F(NetworkVpnServiceTest, OnStart, TestSize.Level1)
94 {
95     instance_->state_ = NetworkVpnService::STATE_RUNNING;
96     instance_->OnStart();
97     instance_->state_ = NetworkVpnService::STATE_STOPPED;
98     EXPECT_EQ(instance_->state_, NetworkVpnService::STATE_STOPPED);
99 }
100 
101 HWTEST_F(NetworkVpnServiceTest, OnStop, TestSize.Level1)
102 {
103     instance_->OnStop();
104     EXPECT_EQ(instance_->state_, NetworkVpnService::STATE_STOPPED);
105 }
106 
107 HWTEST_F(NetworkVpnServiceTest, Dump, TestSize.Level1)
108 {
109     int32_t fd = 1;
110     std::vector<std::u16string> args = {};
111     EXPECT_EQ(instance_->Dump(fd, args), NETMANAGER_EXT_SUCCESS);
112 }
113 
114 HWTEST_F(NetworkVpnServiceTest, Init, TestSize.Level1)
115 {
116     EXPECT_EQ(instance_->Init(), false);
117 }
118 
119 HWTEST_F(NetworkVpnServiceTest, GetDumpMessage, TestSize.Level1)
120 {
121     std::string message;
122     instance_->vpnObj_ = nullptr;
123     instance_->GetDumpMessage(message);
124     int32_t userId = AppExecFwk::Constants::UNSPECIFIED_USERID;
125     sptr<VpnConfig> config = new (std::nothrow) VpnConfig();
126     std::vector<int32_t> activeUserIds;
127     instance_->vpnObj_ = std::make_shared<ExtendedVpnCtl>(config, "", userId, activeUserIds);
128     instance_->GetDumpMessage(message);
129     EXPECT_EQ(message.empty(), false);
130 }
131 
132 HWTEST_F(NetworkVpnServiceTest, Prepare001, TestSize.Level1)
133 {
134     bool isExistVpn = false;
135     bool isRun = false;
136     std::string pkg;
137     EXPECT_EQ(instance_->Prepare(isExistVpn, isRun, pkg), NETMANAGER_EXT_SUCCESS);
138 }
139 
140 HWTEST_F(NetworkVpnServiceTest, SetUpVpn, TestSize.Level1)
141 {
142     int32_t userId = AppExecFwk::Constants::DEFAULT_USERID;
143     sptr<VpnConfig> config = new (std::nothrow) VpnConfig();
144     std::vector<int32_t> activeUserIds;
145     instance_->vpnObj_ = std::make_shared<ExtendedVpnCtl>(config, "", userId, activeUserIds);
146     EXPECT_EQ(instance_->SetUpVpn(config), NETMANAGER_ERR_PERMISSION_DENIED);
147 
148     userId = AppExecFwk::Constants::UNSPECIFIED_USERID;
149     instance_->vpnObj_ = std::make_shared<ExtendedVpnCtl>(config, "", userId, activeUserIds);
150     EXPECT_EQ(instance_->SetUpVpn(config), NETMANAGER_ERR_PERMISSION_DENIED);
151 }
152 
153 HWTEST_F(NetworkVpnServiceTest, Protect, TestSize.Level1)
154 {
155     EXPECT_EQ(instance_->Protect(), NETMANAGER_EXT_SUCCESS);
156 }
157 
158 HWTEST_F(NetworkVpnServiceTest, DestroyVpn, TestSize.Level1)
159 {
160     instance_->vpnObj_ = nullptr;
161     EXPECT_EQ(instance_->DestroyVpn(), NETMANAGER_ERR_PERMISSION_DENIED);
162 }
163 
164 HWTEST_F(NetworkVpnServiceTest, RegisterSharingEventTest001, TestSize.Level1)
165 {
166     int32_t ret = instance_->RegisterVpnEvent(eventCallback_);
167     EXPECT_EQ(ret, NETMANAGER_EXT_ERR_OPERATION_FAILED);
168 }
169 
170 HWTEST_F(NetworkVpnServiceTest, UnregisterSharingEventTest001, TestSize.Level1)
171 {
172     int32_t ret = instance_->UnregisterVpnEvent(eventCallback_);
173     EXPECT_EQ(ret, NETMANAGER_EXT_ERR_OPERATION_FAILED);
174 }
175 
176 HWTEST_F(NetworkVpnServiceTest, CheckCurrentUser, TestSize.Level1)
177 {
178     int32_t userId = 0;
179     std::vector<int32_t> activeUserIds;
180     EXPECT_EQ(instance_->CheckCurrentAccountType(userId, activeUserIds), NETMANAGER_EXT_SUCCESS);
181 }
182 
183 HWTEST_F(NetworkVpnServiceTest, SyncRegisterVpnEvent, TestSize.Level1)
184 {
185     instance_->vpnEventCallbacks_.push_back(eventCallback_);
186     EXPECT_EQ(instance_->SyncRegisterVpnEvent(eventCallback_), NETMANAGER_EXT_ERR_OPERATION_FAILED);
187     instance_->vpnEventCallbacks_.clear();
188     sptr<IVpnEventCallback> eventCallback_1 = new (std::nothrow) VpnEventTestCallback();
189     instance_->vpnEventCallbacks_.push_back(eventCallback_1);
190     sptr<IVpnEventCallback> eventCallback_2 = new (std::nothrow) VpnEventTestCallback();
191     instance_->vpnEventCallbacks_.push_back(eventCallback_2);
192     EXPECT_EQ(instance_->SyncRegisterVpnEvent(eventCallback_), NETMANAGER_EXT_SUCCESS);
193 }
194 
195 HWTEST_F(NetworkVpnServiceTest, SyncUnregisterVpnEvent, TestSize.Level1)
196 {
197     EXPECT_EQ(instance_->SyncUnregisterVpnEvent(eventCallback_), NETMANAGER_EXT_SUCCESS);
198     instance_->vpnEventCallbacks_.clear();
199     EXPECT_EQ(instance_->SyncUnregisterVpnEvent(eventCallback_), NETMANAGER_EXT_ERR_OPERATION_FAILED);
200 }
201 
202 HWTEST_F(NetworkVpnServiceTest, NetworkVpnServiceBranch, TestSize.Level1)
203 {
204     EXPECT_EQ(instance_->CreateVpnConnection(), NETMANAGER_EXT_SUCCESS);
205 }
206 
207 HWTEST_F(NetworkVpnServiceTest, FactoryResetVpnTest001, TestSize.Level1)
208 {
209     EXPECT_EQ(instance_->FactoryResetVpn(), NETMANAGER_EXT_SUCCESS);
210 }
211 
212 HWTEST_F(NetworkVpnServiceTest, OnAddSystemAbility001, TestSize.Level1)
213 {
214     std::string deviceId = "dev1";
215     instance_->OnRemoveSystemAbility(COMM_NETSYS_NATIVE_SYS_ABILITY_ID, deviceId);
216     EXPECT_TRUE(instance_->hasSARemoved_);
217 
218     instance_->OnAddSystemAbility(COMM_NETSYS_NATIVE_SYS_ABILITY_ID, deviceId);
219     EXPECT_FALSE(instance_->hasSARemoved_);
220 }
221 
222 HWTEST_F(NetworkVpnServiceTest, NetworkVpnServiceBranchTest001, TestSize.Level1)
223 {
224     instance_->RecoverVpnConfig();
225     instance_->RegisterFactoryResetCallback();
226     instance_->StartAlwaysOnVpn();
227     instance_->SubscribeCommonEvent();
228     std::string pkg = "";
229     bool enable = false;
230     sptr<VpnConfig> vpnCfg = new (std::nothrow) VpnConfig();
231     ASSERT_TRUE(vpnCfg != nullptr);
232     if (vpnCfg != nullptr) {
233         instance_->SetAlwaysOnVpn(pkg, enable);
234         std::string jsonString = "";
235         instance_->ParseConfigToJson(vpnCfg, jsonString);
236         instance_->ParseJsonToConfig(vpnCfg, jsonString);
237     }
238     int32_t ret = instance_->SetAlwaysOnVpn(pkg, enable);
239     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
240     ret = instance_->GetAlwaysOnVpn(pkg);
241     EXPECT_EQ(ret, NETMANAGER_ERR_INTERNAL);
242 }
243 
244 HWTEST_F(NetworkVpnServiceTest, VpnHapObserverTest001, TestSize.Level1)
245 {
246     AppExecFwk::ProcessData data;
247     instance_->vpnHapObserver_ = new NetworkVpnService::VpnHapObserver(*instance_);
248     if (instance_->vpnHapObserver_ == nullptr) {
249         return;
250     }
251     instance_->vpnHapObserver_->OnProcessDied(data);
252     EXPECT_TRUE(instance_->vpnHapObserver_ != nullptr);
253 }
254 
255 #ifdef SUPPORT_SYSVPN
256 HWTEST_F(NetworkVpnServiceTest, AddSysVpnConfigTest001, TestSize.Level1)
257 {
258     std::string id = "1234";
259     sptr<SysVpnConfig> config = new (std::nothrow) IpsecVpnConfig();
260     config->vpnId_ = id;
261     config->vpnName_ = "test";
262     config->vpnType_ = 1;
263     EXPECT_EQ(instance_->AddSysVpnConfig(config), NETMANAGER_EXT_SUCCESS);
264     // delete test config
265     EXPECT_EQ(instance_->DeleteSysVpnConfig(id), NETMANAGER_EXT_SUCCESS);
266 }
267 
268 HWTEST_F(NetworkVpnServiceTest, AddSysVpnConfigTest002, TestSize.Level1)
269 {
270     sptr<SysVpnConfig> config = nullptr;
271     EXPECT_EQ(instance_->AddSysVpnConfig(config), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
272 }
273 
274 HWTEST_F(NetworkVpnServiceTest, DeleteSysVpnConfigTest001, TestSize.Level1)
275 {
276     std::string id = "1234";
277     sptr<SysVpnConfig> config = new (std::nothrow) IpsecVpnConfig();
278     config->vpnId_ = id;
279     config->vpnName_ = "test";
280     config->vpnType_ = 1;
281     EXPECT_EQ(instance_->AddSysVpnConfig(config), NETMANAGER_EXT_SUCCESS);
282     // delete test config
283     EXPECT_EQ(instance_->DeleteSysVpnConfig(id), NETMANAGER_EXT_SUCCESS);
284 }
285 
286 HWTEST_F(NetworkVpnServiceTest, DeleteSysVpnConfigTest002, TestSize.Level1)
287 {
288     std::string id;
289     EXPECT_EQ(instance_->DeleteSysVpnConfig(id), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
290 }
291 
292 HWTEST_F(NetworkVpnServiceTest, GetSysVpnConfigList001, TestSize.Level1)
293 {
294     std::vector<SysVpnConfig> list;
295     EXPECT_EQ(instance_->GetSysVpnConfigList(list), NETMANAGER_EXT_SUCCESS);
296 }
297 
298 HWTEST_F(NetworkVpnServiceTest, GetSysVpnConfigTest001, TestSize.Level1)
299 {
300     std::string id = "1234";
301     sptr<SysVpnConfig> resConfig = nullptr;
302     EXPECT_EQ(instance_->GetSysVpnConfig(resConfig, id), NETMANAGER_EXT_SUCCESS);
303 }
304 
305 HWTEST_F(NetworkVpnServiceTest, GetSysVpnConfigTest002, TestSize.Level1)
306 {
307     std::string id;
308     sptr<SysVpnConfig> resConfig = nullptr;
309     EXPECT_EQ(instance_->GetSysVpnConfig(resConfig, id), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
310 }
311 
312 HWTEST_F(NetworkVpnServiceTest, GetConnectedSysVpnConfigTest001, TestSize.Level1)
313 {
314     sptr<SysVpnConfig> resConfig = nullptr;
315     EXPECT_EQ(instance_->GetConnectedSysVpnConfig(resConfig), NETMANAGER_EXT_SUCCESS);
316 }
317 #endif // SUPPORT_SYSVPN
318 } // namespace NetManagerStandard
319 } // namespace OHOS
320