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 <memory>
17
18 #include <gtest/gtest.h>
19
20 #include "net_manager_constants.h"
21 #include "vpn_config.h"
22
23 #ifdef GTEST_API_
24 #define private public
25 #define protected public
26 #endif
27
28 #include "ipsec_vpn_ctl.h"
29
30 namespace OHOS {
31 namespace NetManagerStandard {
32 using namespace testing::ext;
33
34 class IpsecVpnCtlTest : public testing::Test {
35 public:
36 static inline std::unique_ptr<IpsecVpnCtl> ipsecControl_ = nullptr;
37 static void SetUpTestSuite();
38 };
39
SetUpTestSuite()40 void IpsecVpnCtlTest::SetUpTestSuite()
41 {
42 sptr<IpsecVpnConfig> ipsecConfig = new (std::nothrow) IpsecVpnConfig();
43 if (ipsecConfig == nullptr) {
44 return;
45 }
46 int32_t userId = 0;
47 std::vector<int32_t> activeUserIds;
48 ipsecControl_ = std::make_unique<IpsecVpnCtl>(ipsecConfig, "pkg", userId, activeUserIds);
49 if (ipsecControl_ == nullptr) {
50 return;
51 }
52 ipsecControl_->ipsecVpnConfig_ = ipsecConfig;
53 }
54
55 HWTEST_F(IpsecVpnCtlTest, SetUp001, TestSize.Level1)
56 {
57 if (ipsecControl_ == nullptr) {
58 return;
59 }
60 EXPECT_EQ(ipsecControl_->SetUp(), NETMANAGER_EXT_SUCCESS);
61 }
62
63 HWTEST_F(IpsecVpnCtlTest, Destroy001, TestSize.Level1)
64 {
65 if (ipsecControl_ == nullptr) {
66 return;
67 }
68 EXPECT_EQ(ipsecControl_->Destroy(), NETMANAGER_EXT_SUCCESS);
69 }
70
71 HWTEST_F(IpsecVpnCtlTest, IsInternalVpn001, TestSize.Level1)
72 {
73 if (ipsecControl_ == nullptr) {
74 return;
75 }
76 EXPECT_EQ(ipsecControl_->IsInternalVpn(), true);
77 }
78
79 HWTEST_F(IpsecVpnCtlTest, GetConnectedSysVpnConfigTest001, TestSize.Level1)
80 {
81 if (ipsecControl_ == nullptr) {
82 return;
83 }
84 sptr<SysVpnConfig> resConfig = nullptr;
85 int32_t ret = ipsecControl_->GetConnectedSysVpnConfig(resConfig);
86 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
87 ipsecControl_->state_ = IpsecVpnStateCode::STATE_CONNECTED;
88 ret = ipsecControl_->GetConnectedSysVpnConfig(resConfig);
89 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
90 sptr<IpsecVpnConfig> tmp = ipsecControl_->ipsecVpnConfig_;
91 ipsecControl_->ipsecVpnConfig_ = nullptr;
92 ret = ipsecControl_->GetConnectedSysVpnConfig(resConfig);
93 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
94 ipsecControl_->ipsecVpnConfig_ = tmp;
95 }
96
97 HWTEST_F(IpsecVpnCtlTest, NotifyConnectStageTest001, TestSize.Level1)
98 {
99 if (ipsecControl_ == nullptr) {
100 return;
101 }
102 std::string stage;
103 int32_t errorCode = 1;
104 int32_t ret = ipsecControl_->NotifyConnectStage(stage, errorCode);
105 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PARAMETER_ERROR);
106
107 stage = IPSEC_START_TAG;
108 ret = ipsecControl_->NotifyConnectStage(stage, errorCode);
109 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_INTERNAL);
110
111 errorCode = NETMANAGER_EXT_SUCCESS;
112 ipsecControl_->state_ = IpsecVpnStateCode::STATE_INIT;
113 ret = ipsecControl_->NotifyConnectStage(stage, errorCode);
114 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
115
116 ipsecControl_->state_ = IpsecVpnStateCode::STATE_STARTED;
117 stage = SWANCTL_START_TAG;
118 ret = ipsecControl_->NotifyConnectStage(stage, errorCode);
119 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
120
121 ipsecControl_->state_ = IpsecVpnStateCode::STATE_CONFIGED;
122 stage = IPSEC_CONNECT_TAG;
123 ret = ipsecControl_->NotifyConnectStage(stage, errorCode);
124 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
125
126 ipsecControl_->state_ = IpsecVpnStateCode::STATE_DISCONNECTED;
127 ret = ipsecControl_->NotifyConnectStage(stage, errorCode);
128 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_INTERNAL);
129
130 stage = "stageTest";
131 ipsecControl_->state_ = IpsecVpnStateCode::STATE_INIT;
132 EXPECT_EQ(ipsecControl_->NotifyConnectStage(stage, errorCode), NETMANAGER_EXT_SUCCESS);
133 ipsecControl_->state_ = IpsecVpnStateCode::STATE_STARTED;
134 EXPECT_EQ(ipsecControl_->NotifyConnectStage(stage, errorCode), NETMANAGER_EXT_SUCCESS);
135 ipsecControl_->state_ = IpsecVpnStateCode::STATE_CONFIGED;
136 EXPECT_EQ(ipsecControl_->NotifyConnectStage(stage, errorCode), NETMANAGER_EXT_SUCCESS);
137 ipsecControl_->state_ = IpsecVpnStateCode::STATE_CONFIGED;
138 stage ="{\"updateconfig\":{\"test\":\"192.168.1.1\"}}";
139 EXPECT_EQ(ipsecControl_->NotifyConnectStage(stage, errorCode), NETMANAGER_EXT_ERR_INTERNAL);
140 }
141
142 HWTEST_F(IpsecVpnCtlTest, NotifyConnectStageTest002, TestSize.Level1)
143 {
144 ASSERT_NE(ipsecControl_, nullptr);
145 std::string stage;
146 int32_t errorCode = 0;
147 int32_t ret = 0;
148 ipsecControl_->state_ = IpsecVpnStateCode::STATE_STARTED;
149 stage = SWANCTL_START_TAG;
150 sptr<MultiVpnInfo> vpnInfo = new (std::nothrow) MultiVpnInfo();
151 ASSERT_NE(vpnInfo, nullptr);
152 ipsecControl_->multiVpnInfo_ = vpnInfo;
153 ret = ipsecControl_->NotifyConnectStage(stage, errorCode);
154 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
155 ipsecControl_->multiVpnInfo_->ifNameId = 1;
156 ret = ipsecControl_->NotifyConnectStage(stage, errorCode);
157 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
158 }
159
160 HWTEST_F(IpsecVpnCtlTest, NotifyConnectStageTest003, TestSize.Level1)
161 {
162 ASSERT_NE(ipsecControl_, nullptr);
163 std::string stage = SWANCTL_START_TAG;
164 int32_t errorCode = 1;
165 int32_t ret = ipsecControl_->NotifyConnectStage(stage, errorCode);
166 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_INTERNAL);
167 sptr<MultiVpnInfo> vpnInfo = new (std::nothrow) MultiVpnInfo();
168 ASSERT_NE(vpnInfo, nullptr);
169 ipsecControl_->multiVpnInfo_ = vpnInfo;
170 ret = ipsecControl_->NotifyConnectStage(stage, errorCode);
171 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_INTERNAL);
172 }
173
174 HWTEST_F(IpsecVpnCtlTest, GetSysVpnCertUriTest001, TestSize.Level1)
175 {
176 sptr<IpsecVpnConfig> config = new (std::nothrow) IpsecVpnConfig();
177 if (config == nullptr) {
178 return;
179 }
180 if (ipsecControl_ == nullptr) {
181 return;
182 }
183 config->ipsecCaCertConf_ = "testCaUri";
184 ipsecControl_->ipsecVpnConfig_ = nullptr;
185 int32_t certType = 0;
186 std::string certUri;
187 EXPECT_EQ(ipsecControl_->GetSysVpnCertUri(certType, certUri), NETMANAGER_EXT_ERR_INTERNAL);
188 ipsecControl_->ipsecVpnConfig_ = config;
189 EXPECT_EQ(ipsecControl_->GetSysVpnCertUri(certType, certUri), NETMANAGER_EXT_SUCCESS);
190 EXPECT_EQ("testCaUri", certUri);
191 }
192
193 HWTEST_F(IpsecVpnCtlTest, GetSysVpnCertUriTest002, TestSize.Level1)
194 {
195 sptr<IpsecVpnConfig> config = new (std::nothrow) IpsecVpnConfig();
196 if (config == nullptr) {
197 return;
198 }
199 if (ipsecControl_ == nullptr) {
200 return;
201 }
202 config->ipsecPublicUserCertConf_ = "testUserUri";
203 ipsecControl_->ipsecVpnConfig_ = config;
204 std::string certUri;
205 int32_t certType = 1;
206 EXPECT_EQ(ipsecControl_->GetSysVpnCertUri(certType, certUri), NETMANAGER_EXT_SUCCESS);
207 EXPECT_EQ("testUserUri", certUri);
208 certType = 2;
209 EXPECT_EQ(ipsecControl_->GetSysVpnCertUri(certType, certUri), NETMANAGER_EXT_SUCCESS);
210 certType = -1;
211 EXPECT_EQ(ipsecControl_->GetSysVpnCertUri(certType, certUri), NETMANAGER_EXT_SUCCESS);
212 }
213
214 HWTEST_F(IpsecVpnCtlTest, GetSysVpnCertUriTest003, TestSize.Level1)
215 {
216 sptr<IpsecVpnConfig> config = new (std::nothrow) IpsecVpnConfig();
217 if (config == nullptr) {
218 return;
219 }
220 if (ipsecControl_ == nullptr) {
221 return;
222 }
223 config->ipsecPublicUserCertConf_ = "testUserUri";
224 ipsecControl_->ipsecVpnConfig_ = config;
225 std::string certUri;
226 int32_t certType = 1;
227 EXPECT_EQ(ipsecControl_->GetSysVpnCertUri(certType, certUri), NETMANAGER_EXT_SUCCESS);
228 EXPECT_EQ("testUserUri", certUri);
229 certType = 3;
230 EXPECT_EQ(ipsecControl_->GetSysVpnCertUri(certType, certUri), NETMANAGER_EXT_SUCCESS);
231 }
232
233 HWTEST_F(IpsecVpnCtlTest, GetVpnCertData001, TestSize.Level1)
234 {
235 sptr<IpsecVpnConfig> config = new (std::nothrow) IpsecVpnConfig();
236 if (config == nullptr) {
237 return;
238 }
239 if (ipsecControl_ == nullptr) {
240 return;
241 }
242 config->pkcs12Password_ = "123456";
243 ipsecControl_->ipsecVpnConfig_ = config;
244 std::vector<int8_t> certData;
245 int32_t certType = 1;
246 EXPECT_EQ(ipsecControl_->GetVpnCertData(certType, certData), NETMANAGER_EXT_SUCCESS);
247 EXPECT_EQ(certData.size(), 0);
248 certType = 3;
249 ipsecControl_->ipsecVpnConfig_ = nullptr;
250 EXPECT_EQ(ipsecControl_->GetVpnCertData(certType, certData), NETMANAGER_EXT_ERR_INTERNAL);
251 std::vector<uint8_t> testCertData{0x30, 0x82, 0x0b, 0xc1, 0x02, 0x01};
252 config->pkcs12FileData_ = testCertData;
253 ipsecControl_->ipsecVpnConfig_ = config;
254 EXPECT_EQ(ipsecControl_->GetVpnCertData(certType, certData), NETMANAGER_EXT_SUCCESS);
255 EXPECT_EQ(certData.size(), 0);
256 certType = 6;
257 EXPECT_EQ(ipsecControl_->GetVpnCertData(certType, certData), NETMANAGER_EXT_SUCCESS);
258 EXPECT_EQ(certData.size(), testCertData.size());
259 certData.clear();
260 config->pkcs12FileData_.clear();
261 EXPECT_EQ(ipsecControl_->GetVpnCertData(certType, certData), NETMANAGER_EXT_SUCCESS);
262 EXPECT_EQ(certData.size(), 0);
263 }
264
265 HWTEST_F(IpsecVpnCtlTest, GetVpnCertData002, TestSize.Level1)
266 {
267 sptr<IpsecVpnConfig> config = new (std::nothrow) IpsecVpnConfig();
268 if (config == nullptr) {
269 return;
270 }
271 if (ipsecControl_ == nullptr) {
272 return;
273 }
274 config->pkcs12Password_ = "123456";
275 ipsecControl_->ipsecVpnConfig_ = config;
276 std::vector<int8_t> certData;
277 int32_t certType = 7;
278 EXPECT_EQ(ipsecControl_->GetVpnCertData(certType, certData), NETMANAGER_EXT_SUCCESS);
279 EXPECT_EQ(certData.size(), config->pkcs12Password_.length());
280 certType = 3;
281 EXPECT_EQ(ipsecControl_->GetVpnCertData(certType, certData), NETMANAGER_EXT_SUCCESS);
282 certType = 7;
283 config->pkcs12Password_ = "";
284 EXPECT_EQ(ipsecControl_->GetVpnCertData(certType, certData), NETMANAGER_EXT_SUCCESS);
285 }
286
287 HWTEST_F(IpsecVpnCtlTest, InitConfigFileTest001, TestSize.Level1)
288 {
289 sptr<IpsecVpnConfig> config = new (std::nothrow) IpsecVpnConfig();
290 if (config == nullptr) {
291 return;
292 }
293 if (ipsecControl_ == nullptr) {
294 return;
295 }
296 config->strongswanConf_ = "INVALID_BASE64";
297 ipsecControl_->ipsecVpnConfig_ = config;
298 EXPECT_EQ(ipsecControl_->InitConfigFile(), NETMANAGER_EXT_SUCCESS);
299 config->strongswanConf_ = "SGVsbG8sIFdvcmxkIQ==";
300 ipsecControl_->ipsecVpnConfig_ = config;
301 EXPECT_EQ(ipsecControl_->InitConfigFile(), NETMANAGER_EXT_SUCCESS);
302 }
303
304 HWTEST_F(IpsecVpnCtlTest, InitConfigFileTest002, TestSize.Level1)
305 {
306 if (ipsecControl_ == nullptr) {
307 return;
308 }
309 ipsecControl_->ipsecVpnConfig_ = nullptr;
310 EXPECT_EQ(ipsecControl_->InitConfigFile(), NETMANAGER_EXT_ERR_INTERNAL);
311 }
312
313 HWTEST_F(IpsecVpnCtlTest, UpdateConfigTest001, TestSize.Level1)
314 {
315 if (ipsecControl_ == nullptr) {
316 return;
317 }
318 ipsecControl_->ipsecVpnConfig_ = nullptr;
319 std::string message;
320 EXPECT_EQ(ipsecControl_->UpdateConfig(message), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
321 message = "test";
322 EXPECT_EQ(ipsecControl_->UpdateConfig(message), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
323 message = "updateconfig";
324 EXPECT_EQ(ipsecControl_->UpdateConfig(message), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
325 message = "updateconfig{}";
326 EXPECT_EQ(ipsecControl_->UpdateConfig(message), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
327 message = "{\"updateconfig\"}";
328 EXPECT_EQ(ipsecControl_->UpdateConfig(message), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
329 message = R"({"config":{"address":"192.168.1.1", "netmask":"255.255.255.0",
330 "mtu":1400, "phyifname":"xfrm"}})";
331 EXPECT_EQ(ipsecControl_->UpdateConfig(message), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
332 message = "{\"updateconfig\":{\"test\":\"192.168.1.1\"}}";
333 EXPECT_EQ(ipsecControl_->UpdateConfig(message), NETMANAGER_EXT_SUCCESS);
334
335 sptr<IpsecVpnConfig> config = new (std::nothrow) IpsecVpnConfig();
336 if (config == nullptr) {
337 return;
338 }
339 ipsecControl_->ipsecVpnConfig_ = config;
340 message = R"({"updateconfig":{"address":"192.168.1.1", "netmask":"255.255.255.0",
341 "mtu":1400, "phyifname":"xfrm"}})";
342 EXPECT_EQ(ipsecControl_->UpdateConfig(message), NETMANAGER_EXT_SUCCESS);
343 message = R"({"updateconfig":{"remoteip":"192.168.1.1","address":"192.168.1.1",
344 "netmask":"255.255.255.0", "mtu":1400, "phyifname":"xfrm"}})";
345 EXPECT_EQ(ipsecControl_->UpdateConfig(message), NETMANAGER_EXT_SUCCESS);
346 ipsecControl_->vpnConfig_ = nullptr;
347 message = R"({"updateconfig":{"address":"192.168.1.1", "netmask":"255.255.255.0",
348 "mtu":1400, "phyifname":"xfrm"}})";
349 EXPECT_EQ(ipsecControl_->UpdateConfig(message), NETMANAGER_EXT_SUCCESS);
350 }
351
352 HWTEST_F(IpsecVpnCtlTest, UpdateConfigTest002, TestSize.Level1)
353 {
354 if (ipsecControl_ == nullptr) {
355 return;
356 }
357 sptr<IpsecVpnConfig> config = new (std::nothrow) IpsecVpnConfig();
358 if (config == nullptr) {
359 return;
360 }
361 std::string message;
362 ipsecControl_->ipsecVpnConfig_ = config;
363
364 INetAddr netAddr;
365 netAddr.address_ = "10.1.0.12";
366 sptr<VpnConfig> vpnConfig = new (std::nothrow) VpnConfig();
367 if (vpnConfig == nullptr) {
368 return;
369 }
370 message = R"({"updateconfig":{"remoteip":"192.168.1.21","address":"10.1.0.12",
371 "netmask":"255.255.255.0", "mtu":1400, "phyifname":"xfrm"}})";
372 EXPECT_EQ(ipsecControl_->UpdateConfig(message), NETMANAGER_EXT_SUCCESS);
373 ipsecControl_->vpnConfig_ = vpnConfig;
374 ipsecControl_->vpnConfig_->addresses_.push_back(netAddr);
375 EXPECT_EQ(ipsecControl_->UpdateConfig(message), NETMANAGER_EXT_SUCCESS);
376 MultiVpnHelper::GetInstance().CreateMultiVpnInfo(
377 "1000", VpnType::L2TP_IPSEC_PSK, ipsecControl_->multiVpnInfo_);
378 ASSERT_NE(ipsecControl_->multiVpnInfo_, nullptr);
379 ipsecControl_->multiVpnInfo_->localAddress = "10.1.0.12";
380 MultiVpnHelper::GetInstance().AddMultiVpnInfo(ipsecControl_->multiVpnInfo_);
381 EXPECT_EQ(ipsecControl_->UpdateConfig(message), NETMANAGER_EXT_ERR_INTERNAL);
382 ipsecControl_->vpnConfig_ = nullptr;
383 EXPECT_EQ(ipsecControl_->UpdateConfig(message), NETMANAGER_EXT_SUCCESS);
384 ipsecControl_->multiVpnInfo_ = nullptr;
385 EXPECT_EQ(ipsecControl_->UpdateConfig(message), NETMANAGER_EXT_SUCCESS);
386 }
387
388 HWTEST_F(IpsecVpnCtlTest, ProcessDnsConfigTest001, TestSize.Level1)
389 {
390 if (ipsecControl_ == nullptr) {
391 return;
392 }
393 ipsecControl_->ipsecVpnConfig_ = nullptr;
394 EXPECT_EQ(ipsecControl_->ProcessDnsConfig(nullptr), NETMANAGER_EXT_ERR_INTERNAL);
395 }
396
397 HWTEST_F(IpsecVpnCtlTest, ProcessDnsConfigTest002, TestSize.Level1)
398 {
399 if (ipsecControl_ == nullptr) {
400 return;
401 }
402 sptr<VpnConfig> vpnConfig = new (std::nothrow) VpnConfig();
403 if (vpnConfig == nullptr) {
404 return;
405 }
406
407 ipsecControl_->vpnConfig_ = vpnConfig;
408 ipsecControl_->vpnConfig_->dnsAddresses_.emplace_back("");
409 ipsecControl_->vpnConfig_->dnsAddresses_.emplace_back("192.168.1.1");
410 std::string message = R"({"updateconfig":{"remoteip":"192.168.1.21",
411 "netmask":"255.255.255.0", "mtu":1400, "phyifname":"xfrm"}})";
412 EXPECT_EQ(ipsecControl_->UpdateConfig(message), NETMANAGER_EXT_SUCCESS);
413
414 message = R"({"updateconfig":{"remoteip":"192.168.1.21", "netmask":"255.255.255.0",
415 "mtu":1400, "phyifname":"xfrm", "primarydns":123, "secondarydns":456}})";
416 EXPECT_EQ(ipsecControl_->UpdateConfig(message), NETMANAGER_EXT_SUCCESS);
417
418 message = R"({"updateconfig":{"remoteip":"192.168.1.21", "netmask":"255.255.255.0",
419 "netmask":"255.255.255.0", "mtu":1400, "phyifname":"xfrm", "primarydns":"", "secondarydns":""}})";
420 EXPECT_EQ(ipsecControl_->UpdateConfig(message), NETMANAGER_EXT_SUCCESS);
421
422 message = R"({"updateconfig":{"remoteip":"192.168.1.21", "netmask":"255.255.255.0",
423 "mtu":1400, "phyifname":"xfrm", "primarydns":"123", "secondarydns":"456"}})";
424 EXPECT_EQ(ipsecControl_->UpdateConfig(message), NETMANAGER_EXT_SUCCESS);
425 }
426
427 HWTEST_F(IpsecVpnCtlTest, HandleUpdateConfigTest001, TestSize.Level1)
428 {
429 if (ipsecControl_ == nullptr) {
430 return;
431 }
432 ipsecControl_->ipsecVpnConfig_ = nullptr;
433 std::string message;
434 EXPECT_EQ(ipsecControl_->HandleUpdateConfig(message), NETMANAGER_EXT_ERR_INTERNAL);
435 message = R"({"updateconfig":{"address":"192.168.1.1", "netmask":"255.255.255.0",
436 "mtu":1400, "phyifname":"xfrm"}})";
437 EXPECT_EQ(ipsecControl_->HandleUpdateConfig(message), NETMANAGER_EXT_ERR_INTERNAL);
438
439 sptr<IpsecVpnConfig> ipsecConfig = new (std::nothrow) IpsecVpnConfig();
440 if (ipsecConfig == nullptr) {
441 return;
442 }
443 int32_t userId = 0;
444 std::vector<int32_t> activeUserIds;
445 ipsecControl_ = std::make_unique<IpsecVpnCtl>(ipsecConfig, "pkg", userId, activeUserIds);
446 ipsecControl_->ipsecVpnConfig_ = ipsecConfig;
447 message = R"({"updateconfig":{"address":"192.168.1.1", "netmask":"255.255.255.0",
448 "mtu":1400, "phyifname":"xfrm"}})";
449 EXPECT_EQ(ipsecControl_->HandleUpdateConfig(message), NETMANAGER_EXT_ERR_INTERNAL);
450 }
451
452 HWTEST_F(IpsecVpnCtlTest, StartSysVpnTest001, TestSize.Level1)
453 {
454 sptr<IpsecVpnConfig> ipsecConfig = new (std::nothrow) IpsecVpnConfig();
455 ASSERT_NE(ipsecConfig, nullptr);
456 int32_t userId = 0;
457 std::vector<int32_t> activeUserIds;
458 std::unique_ptr<IpsecVpnCtl> ipsecControl1
459 = std::make_unique<IpsecVpnCtl>(ipsecConfig, "pkg", userId, activeUserIds);
460 ASSERT_NE(ipsecControl1, nullptr);
461 EXPECT_EQ(ipsecControl1->SetUp(), NETMANAGER_EXT_SUCCESS);
462 std::unique_ptr<IpsecVpnCtl> ipsecControl2
463 = std::make_unique<IpsecVpnCtl>(ipsecConfig, "pkg", userId, activeUserIds);
464 ASSERT_NE(ipsecControl2, nullptr);
465 EXPECT_EQ(ipsecControl2->SetUp(), NETMANAGER_EXT_SUCCESS);
466 }
467
468 HWTEST_F(IpsecVpnCtlTest, DestroyTest002, TestSize.Level1)
469 {
470 sptr<IpsecVpnConfig> ipsecConfig = new (std::nothrow) IpsecVpnConfig();
471 ASSERT_NE(ipsecConfig, nullptr);
472 int32_t userId = 0;
473 std::vector<int32_t> activeUserIds;
474
475 std::unique_ptr<IpsecVpnCtl> ipsecControl
476 = std::make_unique<IpsecVpnCtl>(ipsecConfig, "pkg", userId, activeUserIds);
477 ASSERT_NE(ipsecControl, nullptr);
478 EXPECT_EQ(ipsecControl->Destroy(), NETMANAGER_EXT_SUCCESS);
479
480 std::unique_ptr<IpsecVpnCtl> ipsecControl1
481 = std::make_unique<IpsecVpnCtl>(ipsecConfig, "pkg", userId, activeUserIds);
482 ASSERT_NE(ipsecControl1, nullptr);
483 sptr<MultiVpnInfo> vpnInfo = new (std::nothrow) MultiVpnInfo();
484 ASSERT_NE(vpnInfo, nullptr);
485 ipsecControl1->multiVpnInfo_ = vpnInfo;
486 ipsecControl1->multiVpnInfo_->isVpnExtCall = false;
487 EXPECT_EQ(ipsecControl1->Destroy(), NETMANAGER_EXT_SUCCESS);
488 std::unique_ptr<IpsecVpnCtl> ipsecControl2
489 = std::make_unique<IpsecVpnCtl>(ipsecConfig, "pkg", userId, activeUserIds);
490 ASSERT_NE(ipsecControl2, nullptr);
491 vpnInfo->isVpnExtCall = 1;
492 ipsecControl1->multiVpnInfo_->isVpnExtCall = true;
493 ipsecControl1->multiVpnInfo_->ifNameId = 1;
494 EXPECT_EQ(ipsecControl2->Destroy(), NETMANAGER_EXT_SUCCESS);
495 }
496
497 HWTEST_F(IpsecVpnCtlTest, SetUpVpnTunTest001, TestSize.Level1)
498 {
499 sptr<MultiVpnInfo> vpnInfo = new (std::nothrow) MultiVpnInfo();
500 ASSERT_NE(vpnInfo, nullptr);
501 vpnInfo->isVpnExtCall = 0;
502 vpnInfo->ifNameId = 1;
503 sptr<IpsecVpnConfig> ipsecConfig = new (std::nothrow) IpsecVpnConfig();
504 ASSERT_NE(ipsecConfig, nullptr);
505 int32_t userId = 0;
506 std::vector<int32_t> activeUserIds;
507 std::unique_ptr<IpsecVpnCtl> ipsecControl
508 = std::make_unique<IpsecVpnCtl>(ipsecConfig, "pkg", userId, activeUserIds);
509 ASSERT_NE(ipsecControl, nullptr);
510 ipsecControl->multiVpnInfo_ = vpnInfo;
511 ipsecControl->multiVpnInfo_->isVpnExtCall = true;
512 EXPECT_NE(ipsecControl->SetUpVpnTun(), NETMANAGER_EXT_SUCCESS);
513 ipsecControl->multiVpnInfo_->isVpnExtCall = false;
514 EXPECT_NE(ipsecControl->SetUpVpnTun(), NETMANAGER_EXT_SUCCESS);
515 ipsecConfig->vpnId_ = "123";
516 ipsecConfig->vpnName_ = "xfrm-vpn2";
517 ipsecConfig->vpnType_ = 2;
518 INetAddr netAddr;
519 netAddr.address_ = "10.1.0.12";
520 ipsecConfig->addresses_.push_back(netAddr);
521 ipsecControl->multiVpnInfo_->isVpnExtCall = true;
522 EXPECT_NE(ipsecControl->SetUpVpnTun(), NETMANAGER_EXT_SUCCESS);
523 }
524
525 HWTEST_F(IpsecVpnCtlTest, HandleIpsecConnectFailed001, TestSize.Level1)
526 {
527 ASSERT_NE(ipsecControl_, nullptr);
528 ipsecControl_->state_ = IpsecVpnStateCode::STATE_STARTED;
529 sptr<MultiVpnInfo> vpnInfo = new (std::nothrow) MultiVpnInfo();
530 ASSERT_NE(vpnInfo, nullptr);
531 ipsecControl_->multiVpnInfo_ = vpnInfo;
532 int32_t code = VpnErrorCode::CONNECT_TIME_OUT;
533 ipsecControl_->HandleIpsecConnectFailed(code);
534 EXPECT_TRUE(ipsecControl_->state_ == IpsecVpnStateCode::STATE_DISCONNECTED);
535 code = VpnErrorCode::IKEV2_KEY_ERROR;
536 ipsecControl_->state_ = IpsecVpnStateCode::STATE_STARTED;
537 ipsecControl_->HandleIpsecConnectFailed(code);
538 EXPECT_TRUE(ipsecControl_->state_ ==IpsecVpnStateCode::STATE_DISCONNECTED);
539 code = VpnErrorCode::CA_ERROR;
540 ipsecControl_->state_ = IpsecVpnStateCode::STATE_STARTED;
541 ipsecControl_->HandleIpsecConnectFailed(code);
542 EXPECT_TRUE(ipsecControl_->state_ == IpsecVpnStateCode::STATE_DISCONNECTED);
543 code = VpnErrorCode::PASSWORD_ERROR;
544 ipsecControl_->state_ = IpsecVpnStateCode::STATE_STARTED;
545 ipsecControl_->HandleIpsecConnectFailed(code);
546 EXPECT_TRUE(ipsecControl_->state_ == IpsecVpnStateCode::STATE_DISCONNECTED);
547 code = 300;
548 ipsecControl_->state_ = IpsecVpnStateCode::STATE_STARTED;
549 ipsecControl_->HandleIpsecConnectFailed(code);
550 EXPECT_TRUE(ipsecControl_->state_ == IpsecVpnStateCode::STATE_DISCONNECTED);
551 code = 400;
552 ipsecControl_->state_ = IpsecVpnStateCode::STATE_DISCONNECTED;
553 ipsecControl_->HandleIpsecConnectFailed(code);
554 EXPECT_TRUE(ipsecControl_->state_ == IpsecVpnStateCode::STATE_DISCONNECTED);
555 }
556 } // namespace NetManagerStandard
557 } // namespace OHOS