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 #include "ipsecvpn_config.h"
19 #include "netmanager_ext_test_security.h"
20 #include "networkvpn_service_proxy.h"
21 #include "net_manager_constants.h"
22
23 namespace OHOS {
24 namespace NetManagerStandard {
25 namespace {
26 using namespace testing::ext;
27 } // namespace
28
29 class MockNetIRemoteObject : public IRemoteObject {
30 public:
MockNetIRemoteObject()31 MockNetIRemoteObject() : IRemoteObject(u"mock_i_remote_object") {}
~MockNetIRemoteObject()32 ~MockNetIRemoteObject() {}
33
GetObjectRefCount()34 int32_t GetObjectRefCount() override
35 {
36 return 0;
37 }
38
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)39 int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override
40 {
41 switch (code) {
42 case static_cast<uint32_t>(INetworkVpnService::MessageCode::CMD_DELETE_SYS_VPN_CONFIG):
43 reply.WriteString("test1");
44 break;
45 case static_cast<uint32_t>(INetworkVpnService::MessageCode::CMD_GET_SYS_VPN_CONFIG): {
46 sptr<SysVpnConfig> config = new (std::nothrow) IpsecVpnConfig();
47 if (config == nullptr) {
48 return eCode;
49 }
50 config->vpnId_ = "test2";
51 config->vpnName_ = "test";
52 config->vpnType_ = 1;
53 config->Marshalling(reply);
54 reply.WriteString("test1");
55 break;
56 }
57 case static_cast<uint32_t>(INetworkVpnService::MessageCode::CMD_GET_CONNECTED_SYS_VPN_CONFIG):
58 case static_cast<uint32_t>(INetworkVpnService::MessageCode::CMD_ADD_SYS_VPN_CONFIG):
59 case static_cast<uint32_t>(INetworkVpnService::MessageCode::CMD_START_VPN):
60 case static_cast<uint32_t>(INetworkVpnService::MessageCode::CMD_SETUP_SYS_VPN):
61 case static_cast<uint32_t>(INetworkVpnService::MessageCode::CMD_GET_SYS_VPN_CONFIG_LIST): {
62 sptr<SysVpnConfig> config = new (std::nothrow) IpsecVpnConfig();
63 if (config == nullptr) {
64 return eCode;
65 }
66 config->vpnId_ = "test3";
67 config->vpnName_ = "test";
68 config->vpnType_ = 1;
69 config->Marshalling(reply);
70 break;
71 }
72 case static_cast<uint32_t>(INetworkVpnService::MessageCode::CMD_NOTIFY_CONNECT_STAGE): {
73 reply.WriteString("stop");
74 reply.WriteInt32(1);
75 break;
76 }
77 case static_cast<uint32_t>(INetworkVpnService::MessageCode::CMD_GET_SYS_VPN_CERT_URI):
78 reply.WriteInt32(1);
79 break;
80 default:
81 reply.WriteInt32(1);
82 break;
83 }
84 return eCode;
85 }
86
IsProxyObject() const87 bool IsProxyObject() const override
88 {
89 return true;
90 }
91
CheckObjectLegality() const92 bool CheckObjectLegality() const override
93 {
94 return true;
95 }
96
AddDeathRecipient(const sptr<DeathRecipient> & recipient)97 bool AddDeathRecipient(const sptr<DeathRecipient> &recipient) override
98 {
99 return true;
100 }
101
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)102 bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient) override
103 {
104 return true;
105 }
106
Marshalling(Parcel & parcel) const107 bool Marshalling(Parcel &parcel) const override
108 {
109 return true;
110 }
111
AsInterface()112 sptr<IRemoteBroker> AsInterface() override
113 {
114 return nullptr;
115 }
116
Dump(int fd,const std::vector<std::u16string> & args)117 int Dump(int fd, const std::vector<std::u16string> &args) override
118 {
119 return 0;
120 }
121
GetObjectDescriptor() const122 std::u16string GetObjectDescriptor() const
123 {
124 std::u16string descriptor = std::u16string();
125 return descriptor;
126 }
127
SetErrorCode(int errorCode)128 void SetErrorCode(int errorCode)
129 {
130 eCode = errorCode;
131 }
132
133 private:
134 int eCode = NETMANAGER_EXT_SUCCESS;
135 };
136
137 class NetworkVpnServiceProxyTest : public testing::Test {
138 public:
139 static void SetUpTestCase();
140 static void TearDownTestCase();
141 void SetUp();
142 void TearDown();
143 static inline sptr<MockNetIRemoteObject> remoteObj_ = std::make_unique<MockNetIRemoteObject>().release();
144 static inline std::shared_ptr<NetworkVpnServiceProxy> instance_ =
145 std::make_shared<NetworkVpnServiceProxy>(remoteObj_);
146 };
147
SetUpTestCase()148 void NetworkVpnServiceProxyTest::SetUpTestCase() {}
149
TearDownTestCase()150 void NetworkVpnServiceProxyTest::TearDownTestCase() {}
151
SetUp()152 void NetworkVpnServiceProxyTest::SetUp() {}
153
TearDown()154 void NetworkVpnServiceProxyTest::TearDown() {}
155
156 HWTEST_F(NetworkVpnServiceProxyTest, SetUpVpn001, TestSize.Level1)
157 {
158 NetManagerExtAccessToken token;
159 sptr<SysVpnConfig> config = new (std::nothrow) IpsecVpnConfig();
160 ASSERT_NE(config, nullptr);
161 auto ret = instance_->SetUpVpn(config, true);
162 EXPECT_NE(ret, NETMANAGER_EXT_SUCCESS);
163 config->vpnId_ = "test4";
164 config->vpnName_ = "SetUpVpn001";
165 config->vpnType_ = 1;
166 ret = instance_->SetUpVpn(config, true);
167 EXPECT_NE(ret, NETMANAGER_EXT_SUCCESS);
168 }
169
170 HWTEST_F(NetworkVpnServiceProxyTest, SetUpVpn002, TestSize.Level1)
171 {
172 NetManagerExtAccessToken token;
173 sptr<SysVpnConfig> config = nullptr;
174 auto ret = instance_->SetUpVpn(config);
175 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PARAMETER_ERROR);
176 config = new (std::nothrow) IpsecVpnConfig();
177 ASSERT_NE(config, nullptr);
178 ret = instance_->SetUpVpn(config);
179 EXPECT_NE(ret, NETMANAGER_EXT_SUCCESS);
180 }
181
182 HWTEST_F(NetworkVpnServiceProxyTest, AddSysVpnConfig001, TestSize.Level1)
183 {
184 NetManagerExtAccessToken token;
185 sptr<SysVpnConfig> config = nullptr;
186 auto ret = instance_->AddSysVpnConfig(config);
187 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PARAMETER_ERROR);
188 config = new (std::nothrow) IpsecVpnConfig();
189 ASSERT_NE(config, nullptr);
190 ret = instance_->AddSysVpnConfig(config);
191 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
192 }
193
194 HWTEST_F(NetworkVpnServiceProxyTest, DeleteSysVpnConfig001, TestSize.Level1)
195 {
196 NetManagerExtAccessToken token;
197 std::string vpnId;
198 auto ret = instance_->DeleteSysVpnConfig(vpnId);
199 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PARAMETER_ERROR);
200 }
201
202 HWTEST_F(NetworkVpnServiceProxyTest, GetSysVpnConfig001, TestSize.Level1)
203 {
204 NetManagerExtAccessToken token;
205 std::string vpnId;
206 sptr<SysVpnConfig> resConfig = nullptr;
207 auto ret = instance_->GetSysVpnConfig(resConfig, vpnId);
208 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PARAMETER_ERROR);
209 }
210
211 HWTEST_F(NetworkVpnServiceProxyTest, NotifyConnectStage001, TestSize.Level1)
212 {
213 NetManagerExtAccessToken token;
214 std::string stage;
215 int32_t result = 100;
216 auto ret = instance_->NotifyConnectStage(stage, result);
217 EXPECT_NE(ret, NETMANAGER_EXT_ERR_WRITE_DATA_FAIL);
218 }
219
220 HWTEST_F(NetworkVpnServiceProxyTest, FactoryResetVpn001, TestSize.Level1)
221 {
222 NetManagerExtAccessToken token;
223 auto ret = instance_->FactoryResetVpn();
224 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
225 }
226
227 HWTEST_F(NetworkVpnServiceProxyTest, Protect001, TestSize.Level1)
228 {
229 NetManagerExtAccessToken token;
230 auto ret = instance_->Protect(true);
231 EXPECT_NE(ret, ERR_NONE);
232 }
233
234 HWTEST_F(NetworkVpnServiceProxyTest, DestroyVpn001, TestSize.Level1)
235 {
236 auto ret = instance_->DestroyVpn(true);
237 EXPECT_NE(ret, ERR_NONE);
238 }
239
240 HWTEST_F(NetworkVpnServiceProxyTest, CreateVpnConnection001, TestSize.Level1)
241 {
242 auto ret = instance_->CreateVpnConnection(true);
243 EXPECT_NE(ret, ERR_NONE);
244 }
245 } // namespace NetManagerStandard
246 } // namespace OHOS