1 /*
2 * Copyright (c) 2025 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 "multi_vpn_helper.h"
24 #include "net_manager_constants.h"
25
26 namespace OHOS {
27 namespace NetManagerStandard {
28 using namespace testing::ext;
29
30 class MultiVpnHelperTest : public testing::Test {
31 public:
32 static void SetUpTestCase();
33 static void TearDownTestCase();
34 void SetUp();
35 void TearDown();
36 public:
37 static inline auto &multiVpnHelper_ = MultiVpnHelper::GetInstance();
38 };
39
SetUpTestCase()40 void MultiVpnHelperTest::SetUpTestCase() {}
41
TearDownTestCase()42 void MultiVpnHelperTest::TearDownTestCase() {}
43
SetUp()44 void MultiVpnHelperTest::SetUp() {}
45
TearDown()46 void MultiVpnHelperTest::TearDown() {}
47
48 HWTEST_F(MultiVpnHelperTest, GetNewIfNameId001, TestSize.Level1)
49 {
50 multiVpnHelper_.multiVpnInfos_.clear();
51 EXPECT_EQ(multiVpnHelper_.GetNewIfNameId(), 1);
52 sptr<MultiVpnInfo> info = new (std::nothrow) MultiVpnInfo();
53 ASSERT_NE(info, nullptr);
54 multiVpnHelper_.multiVpnInfos_.emplace_back(info);
55 EXPECT_EQ(multiVpnHelper_.GetNewIfNameId(), 1);
56 multiVpnHelper_.multiVpnInfos_.clear();
57 info->ifNameId = 1;
58 multiVpnHelper_.multiVpnInfos_.emplace_back(info);
59 EXPECT_EQ(multiVpnHelper_.GetNewIfNameId(), 2);
60 }
61
62 HWTEST_F(MultiVpnHelperTest, CreateMultiVpnInfo001, TestSize.Level1)
63 {
64 sptr<MultiVpnInfo> info = nullptr;
65 std::string bundleName = "test";
66 int32_t userId = 1;
67 bool isVpnExtCall = true;
68 EXPECT_EQ(multiVpnHelper_.CreateMultiVpnInfo("testid", 1, info),
69 NETMANAGER_EXT_SUCCESS);
70 }
71
72 HWTEST_F(MultiVpnHelperTest, CreateMultiVpnInfo002, TestSize.Level1)
73 {
74 sptr<SysVpnConfig> vpnConfig = new (std::nothrow) SysVpnConfig();
75 ASSERT_NE(vpnConfig, nullptr);
76 sptr<MultiVpnInfo> info = nullptr;
77 std::string bundleName = "test";
78 int32_t userId = 1;
79 bool isVpnExtCall = true;
80 for (size_t i = 1; i < 21; ++i) {
81 sptr<MultiVpnInfo> vpnInfo = new (std::nothrow) MultiVpnInfo();
82 ASSERT_NE(vpnInfo, nullptr);
83 vpnInfo->ifNameId = i;
84 multiVpnHelper_.multiVpnInfos_.emplace_back(vpnInfo);
85 }
86 EXPECT_EQ(multiVpnHelper_.CreateMultiVpnInfo(vpnConfig->vpnId_, 1, info),
87 NETMANAGER_EXT_ERR_INTERNAL);
88 multiVpnHelper_.multiVpnInfos_.clear();
89 }
90
91 HWTEST_F(MultiVpnHelperTest, CreateMultiVpnInfo003, TestSize.Level1)
92 {
93 multiVpnHelper_.multiVpnInfos_.clear();
94 sptr<MultiVpnInfo> info = nullptr;
95 std::string bundleName = "test";
96 int32_t userId = 1;
97 bool isVpnExtCall = true;
98 sptr<MultiVpnInfo> vpnInfo = new (std::nothrow) MultiVpnInfo();
99 ASSERT_NE(vpnInfo, nullptr);
100 vpnInfo->ifNameId = 1;
101 multiVpnHelper_.multiVpnInfos_.emplace_back(vpnInfo);
102 sptr<SysVpnConfig> vpnConfig = new (std::nothrow) SysVpnConfig();
103 ASSERT_NE(vpnConfig, nullptr);
104 vpnConfig->vpnType_ = VpnType::IKEV2_IPSEC_MSCHAPv2;
105 EXPECT_EQ(multiVpnHelper_.CreateMultiVpnInfo(vpnConfig->vpnId_, vpnConfig->vpnType_, info),
106 NETMANAGER_EXT_SUCCESS);
107 vpnConfig->vpnType_ = VpnType::IKEV2_IPSEC_PSK;
108 EXPECT_EQ(multiVpnHelper_.CreateMultiVpnInfo(vpnConfig->vpnId_, vpnConfig->vpnType_, info),
109 NETMANAGER_EXT_SUCCESS);
110 vpnConfig->vpnType_ = VpnType::IKEV2_IPSEC_RSA;
111 EXPECT_EQ(multiVpnHelper_.CreateMultiVpnInfo(vpnConfig->vpnId_, vpnConfig->vpnType_, info),
112 NETMANAGER_EXT_SUCCESS);
113 vpnConfig->vpnType_ = VpnType::IPSEC_XAUTH_PSK;
114 EXPECT_EQ(multiVpnHelper_.CreateMultiVpnInfo(vpnConfig->vpnId_, vpnConfig->vpnType_, info),
115 NETMANAGER_EXT_SUCCESS);
116 vpnConfig->vpnType_ = VpnType::IPSEC_XAUTH_RSA;
117 EXPECT_EQ(multiVpnHelper_.CreateMultiVpnInfo(vpnConfig->vpnId_, vpnConfig->vpnType_, info),
118 NETMANAGER_EXT_SUCCESS);
119 vpnConfig->vpnType_ = VpnType::IPSEC_HYBRID_RSA;
120 EXPECT_EQ(multiVpnHelper_.CreateMultiVpnInfo(vpnConfig->vpnId_, vpnConfig->vpnType_, info),
121 NETMANAGER_EXT_SUCCESS);
122 vpnConfig->vpnType_ = VpnType::OPENVPN;
123 EXPECT_EQ(multiVpnHelper_.CreateMultiVpnInfo(vpnConfig->vpnId_, vpnConfig->vpnType_, info),
124 NETMANAGER_EXT_SUCCESS);
125 vpnConfig->vpnType_ = VpnType::L2TP_IPSEC_PSK;
126 EXPECT_EQ(multiVpnHelper_.CreateMultiVpnInfo(vpnConfig->vpnId_, vpnConfig->vpnType_, info),
127 NETMANAGER_EXT_SUCCESS);
128 vpnConfig->vpnType_ = VpnType::L2TP_IPSEC_RSA;
129 EXPECT_EQ(multiVpnHelper_.CreateMultiVpnInfo(vpnConfig->vpnId_, vpnConfig->vpnType_, info),
130 NETMANAGER_EXT_SUCCESS);
131 vpnConfig->vpnType_ = VpnType::L2TP;
132 EXPECT_EQ(multiVpnHelper_.CreateMultiVpnInfo(vpnConfig->vpnId_, vpnConfig->vpnType_, info),
133 NETMANAGER_EXT_SUCCESS);
134 multiVpnHelper_.multiVpnInfos_.clear();
135 }
136
137 HWTEST_F(MultiVpnHelperTest, AddMultiVpnInfo001, TestSize.Level1)
138 {
139 multiVpnHelper_.multiVpnInfos_.clear();
140 sptr<MultiVpnInfo> info = nullptr;
141 EXPECT_EQ(multiVpnHelper_.AddMultiVpnInfo(info), NETMANAGER_EXT_ERR_INTERNAL);
142 info = new (std::nothrow) MultiVpnInfo();
143 ASSERT_NE(info, nullptr);
144 EXPECT_EQ(multiVpnHelper_.AddMultiVpnInfo(info), NETMANAGER_EXT_ERR_INTERNAL);
145 info->ifName = "xfrm-vpn1";
146 EXPECT_EQ(multiVpnHelper_.AddMultiVpnInfo(info), NETMANAGER_EXT_SUCCESS);
147 sptr<MultiVpnInfo> info1 = new (std::nothrow) MultiVpnInfo();
148 ASSERT_NE(info1, nullptr);
149 info1->ifName = "xfrm-vpn2";
150 EXPECT_EQ(multiVpnHelper_.AddMultiVpnInfo(info1), NETMANAGER_EXT_SUCCESS);
151 EXPECT_EQ(multiVpnHelper_.AddMultiVpnInfo(info), NETMANAGER_EXT_SUCCESS);
152 multiVpnHelper_.multiVpnInfos_.clear();
153 }
154
155 HWTEST_F(MultiVpnHelperTest, DelMultiVpnInfo001, TestSize.Level1)
156 {
157 multiVpnHelper_.multiVpnInfos_.clear();
158 sptr<MultiVpnInfo> info = nullptr;
159 EXPECT_EQ(multiVpnHelper_.DelMultiVpnInfo(info), NETMANAGER_EXT_ERR_INTERNAL);
160 info = new (std::nothrow) MultiVpnInfo();
161 ASSERT_NE(info, nullptr);
162 EXPECT_EQ(multiVpnHelper_.DelMultiVpnInfo(info), NETMANAGER_EXT_SUCCESS);
163 info->ifName = "xfrm-vpn1";
164 EXPECT_EQ(multiVpnHelper_.AddMultiVpnInfo(info), NETMANAGER_EXT_SUCCESS);
165 EXPECT_EQ(multiVpnHelper_.DelMultiVpnInfo(info), NETMANAGER_EXT_SUCCESS);
166 multiVpnHelper_.multiVpnInfos_.clear();
167 }
168
169 HWTEST_F(MultiVpnHelperTest, StartIpsec001, TestSize.Level1)
170 {
171 multiVpnHelper_.ipsecStartedCount_ = -1;
172 EXPECT_EQ(multiVpnHelper_.StartIpsec(), true);
173 multiVpnHelper_.ipsecStartedCount_ = 0;
174 EXPECT_EQ(multiVpnHelper_.StartIpsec(), true);
175 multiVpnHelper_.ipsecStartedCount_ = 1;
176 EXPECT_EQ(multiVpnHelper_.StartIpsec(), false);
177 }
178
179 HWTEST_F(MultiVpnHelperTest, StopIpsec001, TestSize.Level1)
180 {
181 multiVpnHelper_.ipsecStartedCount_ = 2;
182 multiVpnHelper_.StopIpsec();
183 EXPECT_EQ(multiVpnHelper_.ipsecStartedCount_, 1);
184 }
185
186 HWTEST_F(MultiVpnHelperTest, StartL2tp001, TestSize.Level1)
187 {
188 multiVpnHelper_.l2tpStartedCount_ = -1;
189 EXPECT_EQ(multiVpnHelper_.StartL2tp(), true);
190 multiVpnHelper_.l2tpStartedCount_ = 0;
191 EXPECT_EQ(multiVpnHelper_.StartL2tp(), true);
192 multiVpnHelper_.l2tpStartedCount_ = 1;
193 EXPECT_EQ(multiVpnHelper_.StartL2tp(), false);
194 }
195
196 HWTEST_F(MultiVpnHelperTest, StopL2tp001, TestSize.Level1)
197 {
198 multiVpnHelper_.l2tpStartedCount_ = 2;
199 multiVpnHelper_.StopL2tp();
200 EXPECT_EQ(multiVpnHelper_.l2tpStartedCount_, 1);
201 }
202
203 HWTEST_F(MultiVpnHelperTest, IsConnectedStage001, TestSize.Level1)
204 {
205 std::string stage;
206 EXPECT_EQ(multiVpnHelper_.IsConnectedStage(stage), false);
207 stage = "test";
208 EXPECT_EQ(multiVpnHelper_.IsConnectedStage(stage), false);
209 stage = "connect";
210 EXPECT_EQ(multiVpnHelper_.IsConnectedStage(stage), true);
211 stage = "pppdstart";
212 EXPECT_EQ(multiVpnHelper_.IsConnectedStage(stage), true);
213 stage ="openvpn{\"updateState\":{\"state\":4}}";
214 EXPECT_EQ(multiVpnHelper_.IsConnectedStage(stage), true);
215 }
216
217 HWTEST_F(MultiVpnHelperTest, IsOpenvpnConnectedStage001, TestSize.Level1)
218 {
219 std::string stage;
220 EXPECT_EQ(multiVpnHelper_.IsOpenvpnConnectedStage(stage), false);
221 stage = "test";
222 EXPECT_EQ(multiVpnHelper_.IsOpenvpnConnectedStage(stage), false);
223 stage = "openvpn";
224 EXPECT_EQ(multiVpnHelper_.IsOpenvpnConnectedStage(stage), false);
225 stage = "openvpn{}";
226 EXPECT_EQ(multiVpnHelper_.IsOpenvpnConnectedStage(stage), false);
227 stage ="openvpn{\"config\":{\"state\":4}}";
228 EXPECT_EQ(multiVpnHelper_.IsOpenvpnConnectedStage(stage), false);
229 stage ="openvpn{\"updateState\":{}}";
230 EXPECT_EQ(multiVpnHelper_.IsOpenvpnConnectedStage(stage), false);
231 stage ="openvpn{\"updateState\":{\"test\":4}}";
232 EXPECT_EQ(multiVpnHelper_.IsOpenvpnConnectedStage(stage), false);
233 stage ="openvpn{\"updateState\":{\"state\":5}}";
234 EXPECT_EQ(multiVpnHelper_.IsOpenvpnConnectedStage(stage), false);
235 stage ="openvpn{\"updateState\":{\"state\":4}}";
236 EXPECT_EQ(multiVpnHelper_.IsOpenvpnConnectedStage(stage), true);
237 }
238
239 HWTEST_F(MultiVpnHelperTest, CheckAndCompareMultiVpnLocalAddress001, TestSize.Level1)
240 {
241 multiVpnHelper_.multiVpnInfos_.clear();
242 EXPECT_EQ(multiVpnHelper_.CheckAndCompareMultiVpnLocalAddress("10.2.0.10"), NETMANAGER_EXT_SUCCESS);
243 sptr<MultiVpnInfo> info = new (std::nothrow) MultiVpnInfo();
244 ASSERT_NE(info, nullptr);
245 multiVpnHelper_.multiVpnInfos_.emplace_back(info);
246 EXPECT_EQ(multiVpnHelper_.CheckAndCompareMultiVpnLocalAddress("10.2.0.10"), NETMANAGER_EXT_SUCCESS);
247 multiVpnHelper_.multiVpnInfos_.clear();
248 info->localAddress = "10.2.0.10";
249 multiVpnHelper_.multiVpnInfos_.emplace_back(info);
250 EXPECT_EQ(multiVpnHelper_.CheckAndCompareMultiVpnLocalAddress("10.2.0.10"), NETMANAGER_EXT_ERR_INTERNAL);
251 multiVpnHelper_.multiVpnInfos_.clear();
252 info->localAddress = "10.2.0.12";
253 multiVpnHelper_.multiVpnInfos_.emplace_back(info);
254 EXPECT_EQ(multiVpnHelper_.CheckAndCompareMultiVpnLocalAddress("10.2.0.10"), NETMANAGER_EXT_SUCCESS);
255 info == nullptr;
256 multiVpnHelper_.multiVpnInfos_.emplace_back(info);
257 EXPECT_EQ(multiVpnHelper_.CheckAndCompareMultiVpnLocalAddress("10.2.0.10"), NETMANAGER_EXT_SUCCESS);
258 EXPECT_EQ(multiVpnHelper_.CheckAndCompareMultiVpnLocalAddress(""), NETMANAGER_EXT_SUCCESS);
259 }
260 } // namespace NetManagerStandard
261 } // namespace OHOS