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
18 #ifdef GTEST_API_
19 #define private public
20 #define protected public
21 #endif
22 #include <string>
23 #include <vector>
24
25 #include "inet_addr.h"
26 #include "ipsecvpn_config.h"
27 #include "ipsec_vpn_ctl.h"
28 #include "l2tpvpn_config.h"
29 #include "l2tp_vpn_ctl.h"
30 #include "vpn_template_processor.h"
31 #include "net_manager_constants.h"
32 #include "multi_vpn_helper.h"
33 #include "networkvpn_service.h"
34
35 namespace OHOS {
36 namespace NetManagerStandard {
37 namespace {
38 using namespace testing::ext;
39 }
40
41 class VpnTemplateProcessorTest : public testing::Test {
42 public:
43 static void SetUpTestCase();
44 static void TearDownTestCase();
45 static inline auto networkVpnService_ = DelayedSingleton<NetworkVpnService>::GetInstance();
46 static inline sptr<SysVpnConfig> vpnConfig_ = nullptr;
47 static inline std::string vpnId_ = "test001";
48 static inline std::string vpnBundleName_ = "testBundleName";
49 };
50
SetUpTestCase()51 void VpnTemplateProcessorTest::SetUpTestCase() {}
52
TearDownTestCase()53 void VpnTemplateProcessorTest::TearDownTestCase()
54 {
55 if (vpnConfig_ == nullptr) {
56 return;
57 }
58 networkVpnService_->DeleteSysVpnConfig(vpnId_);
59 }
60
61 HWTEST_F(VpnTemplateProcessorTest, BuildConfig001, TestSize.Level1)
62 {
63 std::shared_ptr<NetVpnImpl> vpnObj = nullptr;
64 std::map<std::string, std::shared_ptr<NetVpnImpl>> vpnObjMap;
65 VpnTemplateProcessor processor;
66 EXPECT_EQ(processor.BuildConfig(vpnObj, vpnObjMap), NETMANAGER_EXT_ERR_INTERNAL);
67 }
68
69 HWTEST_F(VpnTemplateProcessorTest, BuildConfig002, TestSize.Level1)
70 {
71 sptr<L2tpVpnConfig> config = new (std::nothrow) L2tpVpnConfig();
72 ASSERT_NE(config, nullptr);
73 int32_t userId = 0;
74 std::vector<int32_t> activeUserIds;
75 std::shared_ptr<IpsecVpnCtl> sysVpnCtl = std::make_shared<IpsecVpnCtl>(config, "", userId, activeUserIds);
76 ASSERT_NE(sysVpnCtl, nullptr);
77 std::shared_ptr<NetVpnImpl> vpnObj = sysVpnCtl;
78 std::map<std::string, std::shared_ptr<NetVpnImpl>> vpnObjMap;
79 VpnTemplateProcessor processor;
80 EXPECT_EQ(processor.BuildConfig(vpnObj, vpnObjMap), NETMANAGER_EXT_ERR_INTERNAL);
81 }
82
83 HWTEST_F(VpnTemplateProcessorTest, BuildConfig003, TestSize.Level1)
84 {
85 sptr<IpsecVpnConfig> config = new (std::nothrow) IpsecVpnConfig();
86 ASSERT_NE(config, nullptr);
87 sptr<INetAddr> netAddr = new (std::nothrow) INetAddr();
88 ASSERT_NE(netAddr, nullptr);
89 std::string ip = "1.1.1.1";
90 netAddr->address_ = ip;
91 netAddr->prefixlen_ = 1;
92 config->addresses_.push_back(*netAddr);
93 config->vpnId_ = vpnId_;
94 config->vpnName_ = "test001";
95 config->vpnType_ = 2;
96 int32_t userId = AppExecFwk::Constants::UNSPECIFIED_USERID;
97 std::vector<int32_t> activeUserIds;
98 networkVpnService_->CheckCurrentAccountType(userId, activeUserIds);
99 bool isVpnExtCall = true;
100 std::shared_ptr<NetVpnImpl> vpnObj = networkVpnService_->CreateSysVpnCtl(
101 config, userId, activeUserIds, isVpnExtCall);
102 MultiVpnHelper::GetInstance().CreateMultiVpnInfo(config->vpnId_, config->vpnType_,
103 vpnObj->multiVpnInfo_);
104 VpnTemplateProcessor processor;
105 std::map<std::string, std::shared_ptr<NetVpnImpl>> vpnObjMap;
106 EXPECT_EQ(processor.BuildConfig(vpnObj, vpnObjMap), NETMANAGER_EXT_SUCCESS);
107 }
108
109 HWTEST_F(VpnTemplateProcessorTest, BuildConfig004, TestSize.Level1)
110 {
111 sptr<L2tpVpnConfig> config = new (std::nothrow) L2tpVpnConfig();
112 ASSERT_NE(config, nullptr);
113 sptr<INetAddr> netAddr = new (std::nothrow) INetAddr();
114 ASSERT_NE(netAddr, nullptr);
115 std::string ip = "1.1.1.1";
116 netAddr->address_ = ip;
117 netAddr->prefixlen_ = 1;
118 config->addresses_.push_back(*netAddr);
119 config->vpnId_ = vpnId_;
120 config->vpnName_ = "test001";
121 config->vpnType_ = 4;
122 int32_t userId = AppExecFwk::Constants::UNSPECIFIED_USERID;
123 std::vector<int32_t> activeUserIds;
124 networkVpnService_->CheckCurrentAccountType(userId, activeUserIds);
125 bool isVpnExtCall = true;
126 std::shared_ptr<NetVpnImpl> vpnObj = networkVpnService_->CreateSysVpnCtl(
127 config, userId, activeUserIds, isVpnExtCall);
128 MultiVpnHelper::GetInstance().CreateMultiVpnInfo(config->vpnId_, config->vpnType_,
129 vpnObj->multiVpnInfo_);
130 VpnTemplateProcessor processor;
131 std::map<std::string, std::shared_ptr<NetVpnImpl>> vpnObjMap;
132 EXPECT_EQ(processor.BuildConfig(vpnObj, vpnObjMap), NETMANAGER_EXT_SUCCESS);
133 }
134
135 HWTEST_F(VpnTemplateProcessorTest, BuildConfig005, TestSize.Level1)
136 {
137 sptr<L2tpVpnConfig> config = new (std::nothrow) L2tpVpnConfig();
138 ASSERT_NE(config, nullptr);
139 config->vpnId_ = vpnId_;
140 config->vpnName_ = "test001";
141 config->vpnType_ = 4;
142 int32_t userId = AppExecFwk::Constants::UNSPECIFIED_USERID;
143 std::vector<int32_t> activeUserIds;
144 networkVpnService_->CheckCurrentAccountType(userId, activeUserIds);
145 bool isVpnExtCall = true;
146 std::shared_ptr<NetVpnImpl> vpnObj = networkVpnService_->CreateSysVpnCtl(
147 config, userId, activeUserIds, isVpnExtCall);
148 std::map<std::string, std::shared_ptr<NetVpnImpl>> vpnObjMap;
149 VpnTemplateProcessor processor;
150 EXPECT_EQ(processor.BuildConfig(vpnObj, vpnObjMap), NETMANAGER_EXT_ERR_INTERNAL);
151 }
152
153 HWTEST_F(VpnTemplateProcessorTest, BuildConfig006, TestSize.Level1)
154 {
155 sptr<L2tpVpnConfig> config = new (std::nothrow) L2tpVpnConfig();
156 ASSERT_NE(config, nullptr);
157 config->vpnId_ = vpnId_;
158 config->vpnName_ = "test001";
159 config->vpnType_ = 5;
160 sptr<INetAddr> netAddr = new (std::nothrow) INetAddr();
161 ASSERT_NE(netAddr, nullptr);
162 std::string ip = "1.1.1.1";
163 netAddr->address_ = ip;
164 netAddr->prefixlen_ = 1;
165 config->addresses_.push_back(*netAddr);
166 int32_t userId = AppExecFwk::Constants::UNSPECIFIED_USERID;
167 std::vector<int32_t> activeUserIds;
168 networkVpnService_->CheckCurrentAccountType(userId, activeUserIds);
169 bool isVpnExtCall = true;
170 std::shared_ptr<NetVpnImpl> vpnObj = networkVpnService_->CreateSysVpnCtl(
171 config, userId, activeUserIds, isVpnExtCall);
172 MultiVpnHelper::GetInstance().CreateMultiVpnInfo(config->vpnId_, config->vpnType_,
173 vpnObj->multiVpnInfo_);
174 std::map<std::string, std::shared_ptr<NetVpnImpl>> vpnObjMap;
175 VpnTemplateProcessor processor;
176 EXPECT_EQ(processor.BuildConfig(vpnObj, vpnObjMap), NETMANAGER_EXT_SUCCESS);
177 vpnObjMap.insert({config->vpnId_, vpnObj});
178
179 config->vpnId_ = "test4";
180 config->vpnType_ = 4;
181 std::shared_ptr<NetVpnImpl> vpnObj4 = networkVpnService_->CreateSysVpnCtl(
182 config, userId, activeUserIds, isVpnExtCall);
183 MultiVpnHelper::GetInstance().CreateMultiVpnInfo(config->vpnId_, config->vpnType_,
184 vpnObj4->multiVpnInfo_);
185 EXPECT_EQ(processor.BuildConfig(vpnObj4, vpnObjMap), NETMANAGER_EXT_SUCCESS);
186 }
187
188 HWTEST_F(VpnTemplateProcessorTest, BuildConfig007, TestSize.Level1)
189 {
190 sptr<IpsecVpnConfig> config = new (std::nothrow) IpsecVpnConfig();
191 ASSERT_NE(config, nullptr);
192 config->vpnId_ = "test3";
193 config->vpnName_ = "test001";
194 config->vpnType_ = 3;
195 sptr<INetAddr> netAddr = new (std::nothrow) INetAddr();
196 ASSERT_NE(netAddr, nullptr);
197 std::string ip = "1.1.1.1";
198 netAddr->address_ = ip;
199 netAddr->prefixlen_ = 1;
200 config->addresses_.push_back(*netAddr);
201 int32_t userId = AppExecFwk::Constants::UNSPECIFIED_USERID;
202 std::vector<int32_t> activeUserIds;
203 networkVpnService_->CheckCurrentAccountType(userId, activeUserIds);
204 bool isVpnExtCall = true;
205 std::shared_ptr<NetVpnImpl> vpnObj3 = networkVpnService_->CreateSysVpnCtl(
206 config, userId, activeUserIds, isVpnExtCall);
207 MultiVpnHelper::GetInstance().CreateMultiVpnInfo(config->vpnId_, config->vpnType_,
208 vpnObj3->multiVpnInfo_);
209 std::map<std::string, std::shared_ptr<NetVpnImpl>> vpnObjMap;
210 VpnTemplateProcessor processor;
211 EXPECT_EQ(processor.BuildConfig(vpnObj3, vpnObjMap), NETMANAGER_EXT_SUCCESS);
212 vpnObjMap.insert({config->vpnId_, vpnObj3});
213
214 config->vpnType_ = 6;
215 std::shared_ptr<NetVpnImpl> vpnObj6 = networkVpnService_->CreateSysVpnCtl(
216 config, userId, activeUserIds, isVpnExtCall);
217 MultiVpnHelper::GetInstance().CreateMultiVpnInfo(config->vpnId_, config->vpnType_,
218 vpnObj6->multiVpnInfo_);
219 EXPECT_EQ(processor.BuildConfig(vpnObj6, vpnObjMap), NETMANAGER_EXT_SUCCESS);
220
221 config->vpnType_ = 7;
222 std::shared_ptr<NetVpnImpl> vpnObj7 = networkVpnService_->CreateSysVpnCtl(
223 config, userId, activeUserIds, isVpnExtCall);
224 MultiVpnHelper::GetInstance().CreateMultiVpnInfo(config->vpnId_, config->vpnType_,
225 vpnObj7->multiVpnInfo_);
226 EXPECT_EQ(processor.BuildConfig(vpnObj7, vpnObjMap), NETMANAGER_EXT_SUCCESS);
227
228 config->vpnType_ = 8;
229 std::shared_ptr<NetVpnImpl> vpnObj8 = networkVpnService_->CreateSysVpnCtl(
230 config, userId, activeUserIds, isVpnExtCall);
231 MultiVpnHelper::GetInstance().CreateMultiVpnInfo(config->vpnId_, config->vpnType_,
232 vpnObj8->multiVpnInfo_);
233 EXPECT_EQ(processor.BuildConfig(vpnObj8, vpnObjMap), NETMANAGER_EXT_SUCCESS);
234 }
235
236 HWTEST_F(VpnTemplateProcessorTest, BuildConfig008, TestSize.Level1)
237 {
238 sptr<L2tpVpnConfig> config = new (std::nothrow) L2tpVpnConfig();
239 ASSERT_NE(config, nullptr);
240 int32_t userId = 0;
241 std::vector<int32_t> activeUserIds;
242 std::shared_ptr<IpsecVpnCtl> sysVpnCtl = std::make_shared<IpsecVpnCtl>(config, "", userId, activeUserIds);
243 ASSERT_NE(sysVpnCtl, nullptr);
244 sptr<MultiVpnInfo> vpnInfo = new (std::nothrow) MultiVpnInfo();
245 ASSERT_NE(vpnInfo, nullptr);
246 sysVpnCtl->multiVpnInfo_ = vpnInfo;
247 std::shared_ptr<NetVpnImpl> vpnObj = sysVpnCtl;
248 std::map<std::string, std::shared_ptr<NetVpnImpl>> vpnObjMap;
249 VpnTemplateProcessor processor;
250 EXPECT_EQ(processor.BuildConfig(vpnObj, vpnObjMap), NETMANAGER_EXT_SUCCESS);
251 }
252
253 HWTEST_F(VpnTemplateProcessorTest, GenXl2tpdConf001, TestSize.Level1)
254 {
255 sptr<L2tpVpnConfig> config = nullptr;
256 std::map<std::string, std::shared_ptr<NetVpnImpl>> vpnObjMap;
257 VpnTemplateProcessor processor;
258 processor.GenXl2tpdConf(config, 1, vpnObjMap);
259 }
260
261 HWTEST_F(VpnTemplateProcessorTest, GenOptionsL2tpdClient001, TestSize.Level1)
262 {
263 VpnTemplateProcessor processor;
264 sptr<L2tpVpnConfig> config = nullptr;
265 processor.GenOptionsL2tpdClient(config);
266 }
267
268 HWTEST_F(VpnTemplateProcessorTest, CreateXl2tpdConf001, TestSize.Level1)
269 {
270 VpnTemplateProcessor processor;
271 sptr<L2tpVpnConfig> config = nullptr;
272 std::string conf;
273 processor.CreateXl2tpdConf(config, 1, conf);
274 }
275
276 HWTEST_F(VpnTemplateProcessorTest, GetSecret001, TestSize.Level1)
277 {
278 VpnTemplateProcessor processor;
279 sptr<IpsecVpnConfig> ipsecConfig = nullptr;
280 std::string conf;
281 processor.GetSecret(ipsecConfig, 1, conf);
282 }
283
284 HWTEST_F(VpnTemplateProcessorTest, GetConnect001, TestSize.Level1)
285 {
286 VpnTemplateProcessor processor;
287 sptr<IpsecVpnConfig> ipsecConfig = nullptr;
288 std::string conf;
289 processor.GetConnect(ipsecConfig, 1, conf);
290 ipsecConfig= new (std::nothrow) IpsecVpnConfig();
291 ASSERT_NE(ipsecConfig, nullptr);
292 processor.GetConnect(ipsecConfig, 1, conf);
293 sptr<INetAddr> netAddr = new (std::nothrow) INetAddr();
294 ASSERT_NE(netAddr, nullptr);
295 std::string ip = "1.1.1.1";
296 netAddr->address_ = ip;
297 netAddr->prefixlen_ = 1;
298 ipsecConfig->addresses_.push_back(*netAddr);
299 processor.GetConnect(ipsecConfig, 1, conf);
300 ipsecConfig->vpnType_ = -1;
301 processor.GetConnect(ipsecConfig, 1, conf);
302 }
303
304 } // namespace NetManagerStandard
305 } // namespace OHOS