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, UpdateState001, TestSize.Level1)
122 {
123 ASSERT_NE(openvpnControl_, nullptr);
124 std::string msg = OPENVPN_UPDATE;
125 const char *ret = strstr(msg.c_str(), "{");
126 ASSERT_TRUE(ret != nullptr);
127 cJSON* message = cJSON_Parse(ret);
128 ASSERT_TRUE(message != nullptr);
129 cJSON* config = cJSON_GetObjectItem(message, "updateState");
130 ASSERT_TRUE(config != nullptr);
131 ASSERT_TRUE(cJSON_IsObject(config));
132 openvpnControl_->UpdateState(config);
133 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_CONNECTED);
134 }
135
136 HWTEST_F(OpenvpnCtlTest, UpdateState002, TestSize.Level1)
137 {
138 ASSERT_NE(openvpnControl_, nullptr);
139 std::string msg = OPENVPN_UPDATE2;
140 const char *ret = strstr(msg.c_str(), "{");
141 ASSERT_TRUE(ret != nullptr);
142 cJSON* message = cJSON_Parse(ret);
143 ASSERT_TRUE(message != nullptr);
144 cJSON* config = cJSON_GetObjectItem(message, "updateState");
145 ASSERT_TRUE(config != nullptr);
146 ASSERT_TRUE(cJSON_IsObject(config));
147 openvpnControl_->UpdateState(config);
148 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_DISCONNECTED);
149 }
150
151 HWTEST_F(OpenvpnCtlTest, UpdateConfig001, TestSize.Level1)
152 {
153 ASSERT_NE(openvpnControl_, nullptr);
154 std::string msg = OPENVPN_CONFIG;
155 const char *ret = strstr(msg.c_str(), "{");
156 ASSERT_TRUE(ret != nullptr);
157 cJSON* message = cJSON_Parse(ret);
158 ASSERT_TRUE(message != nullptr);
159 cJSON* config = cJSON_GetObjectItem(message, "config");
160 ASSERT_TRUE(config != nullptr);
161 ASSERT_TRUE(cJSON_IsObject(config));
162 openvpnControl_->UpdateConfig(config);
163 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_DISCONNECTED);
164 }
165
166 HWTEST_F(OpenvpnCtlTest, UpdateOpenvpnState001, TestSize.Level1)
167 {
168 ASSERT_NE(openvpnControl_, nullptr);
169 openvpnControl_->UpdateOpenvpnState(OPENVPN_STATE_CONNECTED);
170 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_CONNECTED);
171 openvpnControl_->UpdateOpenvpnState(OPENVPN_STATE_DISCONNECTED);
172 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_DISCONNECTED);
173 openvpnControl_->UpdateOpenvpnState(OPENVPN_STATE_ERROR_PRIVATE_KEY);
174 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_ERROR_PRIVATE_KEY);
175 openvpnControl_->UpdateOpenvpnState(OPENVPN_STATE_ERROR_CLIENT_CRT);
176 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_ERROR_CLIENT_CRT);
177 openvpnControl_->UpdateOpenvpnState(OPENVPN_STATE_ERROR_CA_CAT);
178 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_ERROR_CA_CAT);
179 openvpnControl_->UpdateOpenvpnState(OPENVPN_STATE_ERROR_TIME_OUT);
180 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_ERROR_TIME_OUT);
181 openvpnControl_->UpdateOpenvpnState(-1);
182 EXPECT_EQ(openvpnControl_->openvpnState_, -1);
183 }
184
185 HWTEST_F(OpenvpnCtlTest, StopOpenvpn001, TestSize.Level1)
186 {
187 ASSERT_NE(openvpnControl_, nullptr);
188 openvpnControl_->StopOpenvpn();
189 EXPECT_EQ(openvpnControl_->openvpnState_, OPENVPN_STATE_DISCONNECTED);
190 }
191
192 HWTEST_F(OpenvpnCtlTest, GetConnectedSysVpnConfig001, TestSize.Level1)
193 {
194 ASSERT_NE(openvpnControl_, nullptr);
195 openvpnControl_->UpdateOpenvpnState(OPENVPN_STATE_CONNECTED);
196 sptr<SysVpnConfig> sysVpnConfig = new (std::nothrow) SysVpnConfig();
197 ASSERT_NE(sysVpnConfig, nullptr);
198 EXPECT_EQ(openvpnControl_->GetConnectedSysVpnConfig(sysVpnConfig), NETMANAGER_EXT_SUCCESS);
199 }
200
201 HWTEST_F(OpenvpnCtlTest, IsSystemVpn001, TestSize.Level1)
202 {
203 ASSERT_NE(openvpnControl_, nullptr);
204 EXPECT_EQ(openvpnControl_->IsSystemVpn(), true);
205 }
206
207 HWTEST_F(OpenvpnCtlTest, MaskOpenvpnMessage001, TestSize.Level1)
208 {
209 ASSERT_NE(openvpnControl_, nullptr);
210 EXPECT_EQ(openvpnControl_->MaskOpenvpnMessage(OPENVPN_UPDATE), OPENVPN_UPDATE);
211 EXPECT_EQ(openvpnControl_->MaskOpenvpnMessage(OPENVPN_CONFIG), OPENVPN_CONFIG_MASK);
212 }
213 } // namespace NetManagerStandard
214 } // namespace OHOS