1 /*
2 * Copyright (c) 2023 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 "route.h"
19 #include <gtest/gtest.h>
20
21 #ifdef GTEST_API_
22 #define private public
23 #define protected public
24 #endif
25
26 #include "net_manager_constants.h"
27 #include "net_vpn_impl.h"
28
29 namespace OHOS {
30 namespace NetManagerStandard {
31
32 namespace {
33 using namespace testing::ext;
34 }
35
36 class NetVpnImplInstance : public NetVpnImpl {
37 public:
38 NetVpnImplInstance(sptr<VpnConfig> config, const std::string &pkg, int32_t userId, std::vector<int32_t> &activeUserIds);
39 int32_t SetUp() override;
40 int32_t Destroy() override;
41 bool IsInternalVpn() override;
42 };
43
44 class VpnConnStateCbTest : public IVpnConnStateCb {
45 public:
46 VpnConnStateCbTest() = default;
47 virtual ~VpnConnStateCbTest() = default;
48 void OnVpnConnStateChanged(const VpnConnectState &state) override;
49 };
50
NetVpnImplInstance(sptr<VpnConfig> config,const std::string & pkg,int32_t userId,std::vector<int32_t> & activeUserIds)51 NetVpnImplInstance::NetVpnImplInstance(sptr<VpnConfig> config, const std::string &pkg, int32_t userId, std::vector<int32_t> &activeUserIds)
52 : NetVpnImpl(config, pkg, userId, activeUserIds)
53 {
54 }
55
SetUp()56 int32_t NetVpnImplInstance::SetUp()
57 {
58 return 0;
59 }
60
Destroy()61 int32_t NetVpnImplInstance::Destroy()
62 {
63 return 0;
64 }
65
IsInternalVpn()66 bool NetVpnImplInstance::IsInternalVpn()
67 {
68 return false;
69 }
70
OnVpnConnStateChanged(const VpnConnectState & state)71 void VpnConnStateCbTest::OnVpnConnStateChanged(const VpnConnectState &state) {}
72
73 class NetVpnImplTest : public testing::Test {
74 public:
75 static inline std::unique_ptr<NetVpnImplInstance> netVpnImpl_ = nullptr;
76 static void SetUpTestSuite();
77 };
78
SetUpTestSuite()79 void NetVpnImplTest::SetUpTestSuite()
80 {
81 sptr<VpnConfig> config = new VpnConfig();
82 int32_t userId = 100;
83 std::vector<int32_t> activeUserIds;
84 netVpnImpl_ = std::make_unique<NetVpnImplInstance>(config, "pkg", userId, activeUserIds);
85 }
86
87 HWTEST_F(NetVpnImplTest, SetUp, TestSize.Level1)
88 {
89 EXPECT_EQ(netVpnImpl_->SetUp(), NETMANAGER_EXT_SUCCESS);
90 }
91
92 HWTEST_F(NetVpnImplTest, Destroy, TestSize.Level1)
93 {
94 EXPECT_EQ(netVpnImpl_->Destroy(), NETMANAGER_EXT_SUCCESS);
95 }
96
97 HWTEST_F(NetVpnImplTest, IsVpnConnecting, TestSize.Level1)
98 {
99 EXPECT_EQ(netVpnImpl_->IsVpnConnecting(), false);
100 }
101
102 HWTEST_F(NetVpnImplTest, RegisterConnectStateChangedCb001, TestSize.Level1)
103 {
104 std::shared_ptr<VpnConnStateCbTest> callback = nullptr;
105 VpnConnectState state = VpnConnectState::VPN_CONNECTED;
106 netVpnImpl_->NotifyConnectState(state);
107 EXPECT_EQ(netVpnImpl_->RegisterConnectStateChangedCb(callback), NETMANAGER_EXT_ERR_INTERNAL);
108 }
109
110 HWTEST_F(NetVpnImplTest, RegisterConnectStateChangedCb002, TestSize.Level1)
111 {
112 std::shared_ptr<VpnConnStateCbTest> callback = std::make_shared<VpnConnStateCbTest>();
113 VpnConnectState state = VpnConnectState::VPN_CONNECTED;
114 netVpnImpl_->NotifyConnectState(state);
115 EXPECT_EQ(netVpnImpl_->RegisterConnectStateChangedCb(callback), NETMANAGER_EXT_SUCCESS);
116 }
117
118 HWTEST_F(NetVpnImplTest, RegisterNetSupplier, TestSize.Level1)
119 {
120 auto& netConnClientIns = NetConnClient::GetInstance();
121 netVpnImpl_->netSupplierId_ = 1;
122 EXPECT_EQ(netVpnImpl_->RegisterNetSupplier(netConnClientIns), false);
123 netVpnImpl_->netSupplierId_ = 0;
124 netVpnImpl_->vpnConfig_->isMetered_ = false;
125 EXPECT_EQ(netVpnImpl_->RegisterNetSupplier(netConnClientIns), false);
126 }
127
128 HWTEST_F(NetVpnImplTest, UpdateNetSupplierInfo, TestSize.Level1)
129 {
130 auto& netConnClientIns = NetConnClient::GetInstance();
131 netVpnImpl_->netSupplierId_ = 0;
132 netVpnImpl_->UnregisterNetSupplier(netConnClientIns);
133 netVpnImpl_->netSupplierId_ = 1;
134 netVpnImpl_->UnregisterNetSupplier(netConnClientIns);
135 netVpnImpl_->netSupplierInfo_ = nullptr;
136 EXPECT_EQ(netVpnImpl_->UpdateNetSupplierInfo(netConnClientIns, true), false);
137 netVpnImpl_->netSupplierId_ = 0;
138 EXPECT_EQ(netVpnImpl_->UpdateNetSupplierInfo(netConnClientIns, true), false);
139 netVpnImpl_->netSupplierId_ = 1;
140 netVpnImpl_->netSupplierInfo_ = new (std::nothrow) NetSupplierInfo();
141 EXPECT_EQ(netVpnImpl_->UpdateNetSupplierInfo(netConnClientIns, true), true);
142 }
143
144 HWTEST_F(NetVpnImplTest, UpdateNetLinkInfo001, TestSize.Level1)
145 {
146 auto& netConnClientIns = NetConnClient::GetInstance();
147 netVpnImpl_->vpnConfig_ = nullptr;
148 EXPECT_EQ(netVpnImpl_->UpdateNetLinkInfo(netConnClientIns), false);
149 netVpnImpl_->vpnConfig_ = new (std::nothrow) VpnConfig();
150 Route route1, toute2;
151 netVpnImpl_->vpnConfig_->routes_.push_back(route1);
152 netVpnImpl_->vpnConfig_->routes_.push_back(toute2);
153 std::string dnsServer1 = "192.168.1.0";
154 std::string dnsServer2 = "192.168.2.0";
155 netVpnImpl_->vpnConfig_->dnsAddresses_.push_back(dnsServer1);
156 netVpnImpl_->vpnConfig_->dnsAddresses_.push_back(dnsServer2);
157 std::string domain1 = "baidu.com";
158 std::string domain2 = "changhong.com";
159 netVpnImpl_->vpnConfig_->searchDomains_.push_back(domain1);
160 netVpnImpl_->vpnConfig_->searchDomains_.push_back(domain2);
161 EXPECT_EQ(netVpnImpl_->UpdateNetLinkInfo(netConnClientIns), true);
162 }
163
164 HWTEST_F(NetVpnImplTest, UpdateNetLinkInfo002, TestSize.Level1)
165 {
166 auto& netConnClientIns = NetConnClient::GetInstance();
167 netVpnImpl_->vpnConfig_ = nullptr;
168 EXPECT_EQ(netVpnImpl_->UpdateNetLinkInfo(netConnClientIns), false);
169 netVpnImpl_->vpnConfig_ = new (std::nothrow) VpnConfig();
170 netVpnImpl_->vpnConfig_->isAcceptIPv4_ = true;
171 EXPECT_EQ(netVpnImpl_->UpdateNetLinkInfo(netConnClientIns), true);
172 netVpnImpl_->vpnConfig_->isAcceptIPv4_ = false;
173 netVpnImpl_->vpnConfig_->isAcceptIPv4_ = true;
174 EXPECT_EQ(netVpnImpl_->UpdateNetLinkInfo(netConnClientIns), true);
175 netVpnImpl_->vpnConfig_->isAcceptIPv4_ = false;
176 netVpnImpl_->vpnConfig_->isAcceptIPv4_ = false;
177 EXPECT_EQ(netVpnImpl_->UpdateNetLinkInfo(netConnClientIns), true);
178 }
179
180 HWTEST_F(NetVpnImplTest, GenerateUidRangesByAcceptedApps, TestSize.Level1)
181 {
182 std::set<int32_t> uids = {1, 2, 3};
183 std::vector<int32_t> beginUids;
184 std::vector<int32_t> endUids;
185 netVpnImpl_->GenerateUidRangesByAcceptedApps(uids, beginUids, endUids);
186 EXPECT_EQ(beginUids.empty(), false);
187 }
188
189 HWTEST_F(NetVpnImplTest, GenerateUidRangesByRefusedApps, TestSize.Level1)
190 {
191 std::set<int32_t> uids = {1, 2, 3};
192 std::vector<int32_t> beginUids;
193 std::vector<int32_t> endUids;
194 int32_t userId = 0;
195 netVpnImpl_->GenerateUidRangesByRefusedApps(userId, uids, beginUids, endUids);
196 EXPECT_EQ(beginUids.empty(), false);
197 }
198
199 HWTEST_F(NetVpnImplTest, GetAppsUids, TestSize.Level1)
200 {
201 std::vector<std::string> applications = {"com.baidu.searchbox", "com.quark.browser"};
202 int32_t userId = 0;
203 std::set<int32_t> uids = netVpnImpl_->GetAppsUids(userId, applications);
204 EXPECT_EQ(uids.empty(), true);
205 }
206
207 HWTEST_F(NetVpnImplTest, GenerateUidRanges, TestSize.Level1)
208 {
209 std::vector<int32_t> beginUids;
210 std::vector<int32_t> endUids;
211 netVpnImpl_->userId_ = AppExecFwk::Constants::INVALID_USERID;
212 netVpnImpl_->vpnConfig_->acceptedApplications_ = {"com.baidu.searchbox", "com.quark.browser"};
213 int32_t userId = 0;
214 netVpnImpl_->vpnConfig_->refusedApplications_ = {"com.qq.reader", "com.tencent.mm"};
215 int32_t result = netVpnImpl_->GenerateUidRanges(userId, beginUids, endUids);
216 EXPECT_EQ(result, NETMANAGER_EXT_SUCCESS);
217 }
218
219 HWTEST_F(NetVpnImplTest, ResumeUids001, TestSize.Level1)
220 {
221 int32_t result = netVpnImpl_->ResumeUids();
222 EXPECT_EQ(result, NETMANAGER_EXT_ERR_INTERNAL);
223 }
224 } // namespace NetManagerStandard
225 } // namespace OHOS
226