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 #ifdef GTEST_API_
21 #define private public
22 #endif
23 #include "net_manager_constants.h"
24 #include "netmanager_ext_test_security.h"
25 #include "open_vpn_ctl.h"
26 #include "vpn_config.h"
27
28 namespace OHOS {
29 namespace NetManagerStandard {
30 using namespace testing::ext;
31 constexpr const char *OPENVPN_CONFIG =
32 "openvpn{\"config\":{\"address\":\"10.8.0.3\", \"netmask\":\"255.255.255.0\", \"mtu\":1500}}";
33 constexpr const char *OPENVPN_CONFIG_MASK = "openvpn{\"config***";
34 constexpr const char *OPENVPN_UPDATE = "openvpn{\"updateState\":{\"state\":4}}";
35 constexpr const char *OPENVPN_UPDATE2 = "openvpn{\"updateState\":{\"state\":203}}";
36
37 class OpenvpnCtlTest : public testing::Test {
38 public:
39 static inline std::unique_ptr<OpenvpnCtl> openvpnControl_ = nullptr;
40 // static inline std::unique_ptr<NetVpnImpl> netVpnImpl_ = nullptr;
41 static void SetUpTestSuite();
42 };
43
SetUpTestSuite()44 void OpenvpnCtlTest::SetUpTestSuite()
45 {
46 sptr<OpenvpnConfig> openvpnConfig = new (std::nothrow) OpenvpnConfig();
47 ASSERT_NE(openvpnConfig, nullptr);
48 int32_t userId = 0;
49 std::vector<int32_t> activeUserIds;
50 openvpnControl_ =
51 std::make_unique<OpenvpnCtl>(openvpnConfig, "pkg", userId, activeUserIds);
52 ASSERT_NE(openvpnControl_, nullptr);
53 openvpnControl_->openvpnConfig_ = openvpnConfig;
54 }
55
56 HWTEST_F(OpenvpnCtlTest, SetUp001, TestSize.Level1)
57 {
58 ASSERT_NE(openvpnControl_, nullptr);
59 EXPECT_EQ(openvpnControl_->SetUp(), NETMANAGER_EXT_SUCCESS);
60 }
61
62 HWTEST_F(OpenvpnCtlTest, Destroy001, TestSize.Level1)
63 {
64 ASSERT_NE(openvpnControl_, nullptr);
65 EXPECT_EQ(openvpnControl_->Destroy(), NETMANAGER_EXT_SUCCESS);
66 }
67
68 HWTEST_F(OpenvpnCtlTest, IsInternalVpn001, TestSize.Level1)
69 {
70 ASSERT_NE(openvpnControl_, nullptr);
71 EXPECT_EQ(openvpnControl_->IsInternalVpn(), true);
72 }
73
74 HWTEST_F(OpenvpnCtlTest, GetConnectedSysVpnConfigTest001, TestSize.Level1)
75 {
76 ASSERT_NE(openvpnControl_, nullptr);
77 sptr<SysVpnConfig> resConfig = nullptr;
78 EXPECT_EQ(openvpnControl_->GetConnectedSysVpnConfig(resConfig), NETMANAGER_EXT_SUCCESS);
79 std::string stage = OPENVPN_UPDATE;
80 openvpnControl_->NotifyConnectStage(stage, 0);
81 EXPECT_EQ(openvpnControl_->GetConnectedSysVpnConfig(resConfig), NETMANAGER_EXT_SUCCESS);
82 ASSERT_NE(resConfig, nullptr);
83 }
84
85 HWTEST_F(OpenvpnCtlTest, NotifyConnectStageTest001, TestSize.Level1)
86 {
87 ASSERT_NE(openvpnControl_, nullptr);
88 std::string stage = "connect";
89 int32_t errorCode = 100;
90 EXPECT_EQ(openvpnControl_->NotifyConnectStage(stage, errorCode), NETMANAGER_EXT_ERR_INTERNAL);
91 stage = OPENVPN_CONFIG;
92 EXPECT_EQ(openvpnControl_->NotifyConnectStage(stage, errorCode), NETMANAGER_EXT_ERR_INTERNAL);
93 errorCode = 0;
94 EXPECT_EQ(openvpnControl_->NotifyConnectStage(stage, errorCode), NETMANAGER_EXT_SUCCESS);
95 stage = "";
96 EXPECT_EQ(openvpnControl_->NotifyConnectStage(stage, errorCode), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
97 }
98
99 HWTEST_F(OpenvpnCtlTest, HandleClientMessage001, TestSize.Level1)
100 {
101 ASSERT_NE(openvpnControl_, nullptr);
102 std::string msg = "";
103 openvpnControl_->HandleClientMessage(msg);
104 msg = "openvpn";
105 openvpnControl_->HandleClientMessage(msg);
106 msg = "openvpn{test}";
107 openvpnControl_->HandleClientMessage(msg);
108 msg = OPENVPN_CONFIG;
109 openvpnControl_->HandleClientMessage(msg);
110 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_CONNECTED);
111
112 msg = OPENVPN_UPDATE;
113 openvpnControl_->HandleClientMessage(msg);
114 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_CONNECTED);
115
116 msg = OPENVPN_UPDATE2;
117 openvpnControl_->HandleClientMessage(msg);
118 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_DISCONNECTED);
119 }
120
121 HWTEST_F(OpenvpnCtlTest, HandleClientMessage002, TestSize.Level1)
122 {
123 int32_t ret;
124 std::string msg = R"(openvpn{"setupVpnTun":{"ip":"192.168.1.100"}})";
125 ret = openvpnControl_->HandleClientMessage(msg);
126 EXPECT_NE(ret, NETMANAGER_EXT_SUCCESS);
127 sptr<MultiVpnInfo> vpnInfo = new (std::nothrow) MultiVpnInfo();
128 ASSERT_NE(vpnInfo, nullptr);
129 openvpnControl_->multiVpnInfo_ = vpnInfo;
130 ret = openvpnControl_->HandleClientMessage(msg);
131 EXPECT_NE(ret, NETMANAGER_EXT_SUCCESS);
132 }
133
134 HWTEST_F(OpenvpnCtlTest, GetSysVpnCertUriTest001, TestSize.Level1)
135 {
136 openvpnControl_->openvpnConfig_ = nullptr;
137 int32_t ret;
138 std::string uri;
139 ret = openvpnControl_->GetSysVpnCertUri(1, uri);
140 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_INTERNAL);
141 sptr<OpenvpnConfig> openvpnConfig = new (std::nothrow) OpenvpnConfig();
142 ASSERT_NE(openvpnConfig, nullptr);
143 openvpnControl_->openvpnConfig_ = openvpnConfig;
144 ret = openvpnControl_->GetSysVpnCertUri(0, uri);
145 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
146 ret = openvpnControl_->GetSysVpnCertUri(1, uri);
147 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
148 }
149
150 HWTEST_F(OpenvpnCtlTest, UpdateState001, TestSize.Level1)
151 {
152 ASSERT_NE(openvpnControl_, nullptr);
153 std::string msg = OPENVPN_UPDATE;
154 const char *ret = strstr(msg.c_str(), "{");
155 ASSERT_TRUE(ret != nullptr);
156 cJSON* message = cJSON_Parse(ret);
157 ASSERT_TRUE(message != nullptr);
158 cJSON* config = cJSON_GetObjectItem(message, "updateState");
159 ASSERT_TRUE(config != nullptr);
160 ASSERT_TRUE(cJSON_IsObject(config));
161 openvpnControl_->UpdateState(config);
162 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_CONNECTED);
163 }
164
165 HWTEST_F(OpenvpnCtlTest, UpdateState002, TestSize.Level1)
166 {
167 ASSERT_NE(openvpnControl_, nullptr);
168 std::string msg = OPENVPN_UPDATE2;
169 const char *ret = strstr(msg.c_str(), "{");
170 ASSERT_TRUE(ret != nullptr);
171 cJSON* message = cJSON_Parse(ret);
172 ASSERT_TRUE(message != nullptr);
173 cJSON* config = cJSON_GetObjectItem(message, "updateState");
174 ASSERT_TRUE(config != nullptr);
175 ASSERT_TRUE(cJSON_IsObject(config));
176 openvpnControl_->UpdateState(config);
177 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_DISCONNECTED);
178 sptr<MultiVpnInfo> vpnInfo = new (std::nothrow) MultiVpnInfo();
179 ASSERT_NE(vpnInfo, nullptr);
180 openvpnControl_->multiVpnInfo_ = vpnInfo;
181 openvpnControl_->UpdateState(config);
182 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_DISCONNECTED);
183 }
184
185 HWTEST_F(OpenvpnCtlTest, UpdateConfig001, TestSize.Level1)
186 {
187 ASSERT_NE(openvpnControl_, nullptr);
188 std::string msg = OPENVPN_CONFIG;
189 const char *ret = strstr(msg.c_str(), "{");
190 ASSERT_TRUE(ret != nullptr);
191 cJSON* message = cJSON_Parse(ret);
192 ASSERT_TRUE(message != nullptr);
193 cJSON* config = cJSON_GetObjectItem(message, "config");
194 ASSERT_TRUE(config != nullptr);
195 ASSERT_TRUE(cJSON_IsObject(config));
196 openvpnControl_->UpdateConfig(config);
197 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_DISCONNECTED);
198 }
199
200 HWTEST_F(OpenvpnCtlTest, UpdateOpenvpnState001, TestSize.Level1)
201 {
202 ASSERT_NE(openvpnControl_, nullptr);
203 openvpnControl_->UpdateOpenvpnState(OPENVPN_STATE_CONNECTED);
204 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_CONNECTED);
205 openvpnControl_->UpdateOpenvpnState(OPENVPN_STATE_DISCONNECTED);
206 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_DISCONNECTED);
207 openvpnControl_->UpdateOpenvpnState(OPENVPN_STATE_ERROR_PRIVATE_KEY);
208 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_ERROR_PRIVATE_KEY);
209 openvpnControl_->UpdateOpenvpnState(OPENVPN_STATE_ERROR_CLIENT_CRT);
210 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_ERROR_CLIENT_CRT);
211 openvpnControl_->UpdateOpenvpnState(OPENVPN_STATE_ERROR_CA_CAT);
212 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_ERROR_CA_CAT);
213 openvpnControl_->UpdateOpenvpnState(OPENVPN_STATE_ERROR_TIME_OUT);
214 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_ERROR_TIME_OUT);
215 openvpnControl_->UpdateOpenvpnState(-1);
216 EXPECT_EQ(openvpnControl_->openvpnState_, -1);
217 }
218
219 HWTEST_F(OpenvpnCtlTest, StopOpenvpn001, TestSize.Level1)
220 {
221 ASSERT_NE(openvpnControl_, nullptr);
222 openvpnControl_->StopOpenvpn();
223 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_DISCONNECTED);
224 }
225
226 HWTEST_F(OpenvpnCtlTest, GetConnectedSysVpnConfig001, TestSize.Level1)
227 {
228 ASSERT_NE(openvpnControl_, nullptr);
229 openvpnControl_->UpdateOpenvpnState(OPENVPN_STATE_CONNECTED);
230 sptr<SysVpnConfig> sysVpnConfig = new (std::nothrow) SysVpnConfig();
231 ASSERT_NE(sysVpnConfig, nullptr);
232 EXPECT_EQ(openvpnControl_->GetConnectedSysVpnConfig(sysVpnConfig), NETMANAGER_EXT_SUCCESS);
233 }
234
235 HWTEST_F(OpenvpnCtlTest, IsSystemVpn001, TestSize.Level1)
236 {
237 ASSERT_NE(openvpnControl_, nullptr);
238 EXPECT_EQ(openvpnControl_->IsSystemVpn(), true);
239 }
240
241 HWTEST_F(OpenvpnCtlTest, MaskOpenvpnMessage001, TestSize.Level1)
242 {
243 ASSERT_NE(openvpnControl_, nullptr);
244 EXPECT_EQ(openvpnControl_->MaskOpenvpnMessage(OPENVPN_UPDATE), OPENVPN_UPDATE);
245 EXPECT_EQ(openvpnControl_->MaskOpenvpnMessage(OPENVPN_CONFIG), OPENVPN_CONFIG_MASK);
246 }
247
248 HWTEST_F(OpenvpnCtlTest, GetVpnCertData001, TestSize.Level1)
249 {
250 if (openvpnControl_ != nullptr) {
251 std::vector<int8_t> certData;
252 EXPECT_EQ(openvpnControl_->GetVpnCertData(1, certData), NETMANAGER_EXT_SUCCESS);
253 }
254 }
255 } // namespace NetManagerStandard
256 } // namespace OHOS