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
23 #include "mock_networkvpn_service_stub_test.h"
24 #include "mock_vpn_event_callback_test.h"
25 #include "sharing_event_callback_stub.h"
26 #include "net_manager_constants.h"
27 #include "network_vpn_service_stub.h"
28 #include "netmanager_ext_test_security.h"
29
30 namespace OHOS {
31 namespace NetManagerStandard {
32 using namespace testing::ext;
33 class NetworkVpnServiceStubTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp();
38 void TearDown();
39 static inline std::shared_ptr<MockNetworkVpnServiceStub> instance_ = std::make_shared<MockNetworkVpnServiceStub>();
40 static int32_t SendRemoteRequest(MessageParcel &data, INetworkVpnServiceIpcCode code);
41 };
42
SetUpTestCase()43 void NetworkVpnServiceStubTest::SetUpTestCase() {}
44
TearDownTestCase()45 void NetworkVpnServiceStubTest::TearDownTestCase() {}
46
SetUp()47 void NetworkVpnServiceStubTest::SetUp() {}
48
TearDown()49 void NetworkVpnServiceStubTest::TearDown() {}
50
SendRemoteRequest(MessageParcel & data,INetworkVpnServiceIpcCode code)51 int32_t NetworkVpnServiceStubTest::SendRemoteRequest(MessageParcel &data, INetworkVpnServiceIpcCode code)
52 {
53 MessageParcel reply;
54 MessageOption option;
55 return instance_->OnRemoteRequest(static_cast<uint32_t>(code), data, reply, option);
56 }
57
58 HWTEST_F(NetworkVpnServiceStubTest, ReplyPrepareTest001, TestSize.Level1)
59 {
60 NetManagerExtAccessToken token;
61 MessageParcel data;
62 if (!data.WriteInterfaceToken(NetworkVpnServiceStub::GetDescriptor())) {
63 return;
64 }
65 int32_t ret = SendRemoteRequest(data, INetworkVpnServiceIpcCode::COMMAND_PREPARE);
66 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
67 }
68
69 HWTEST_F(NetworkVpnServiceStubTest, ReplySetUpVpnTest001, TestSize.Level1)
70 {
71 NetManagerExtAccessToken token;
72 MessageParcel data;
73 if (!data.WriteInterfaceToken(NetworkVpnServiceStub::GetDescriptor())) {
74 return;
75 }
76 VpnConfig* config = new (std::nothrow) VpnConfig();
77 EXPECT_TRUE(config != nullptr);
78 if (config == nullptr) {
79 return;
80 }
81 config->isAcceptIPv4_ = false;
82 config->isAcceptIPv6_ = false;
83 config->isLegacy_ = false;
84 config->isMetered_ = false;
85 config->isBlocking_ = false;
86 if (!config->Marshalling(data)) {
87 return;
88 }
89 int32_t ret = SendRemoteRequest(data, INetworkVpnServiceIpcCode::COMMAND_SET_UP_VPN);
90 EXPECT_NE(ret, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
91 }
92
93 HWTEST_F(NetworkVpnServiceStubTest, ReplyProtectTest001, TestSize.Level1)
94 {
95 NetManagerExtAccessToken token;
96 MessageParcel data;
97 if (!data.WriteInterfaceToken(NetworkVpnServiceStub::GetDescriptor())) {
98 return;
99 }
100 int32_t ret = SendRemoteRequest(data, INetworkVpnServiceIpcCode::COMMAND_PROTECT);
101 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
102 }
103
104 HWTEST_F(NetworkVpnServiceStubTest, ReplyDestroyVpnTest001, TestSize.Level1)
105 {
106 NetManagerExtAccessToken token;
107 MessageParcel data;
108 if (!data.WriteInterfaceToken(NetworkVpnServiceStub::GetDescriptor())) {
109 return;
110 }
111 int32_t ret = SendRemoteRequest(data, INetworkVpnServiceIpcCode::COMMAND_DESTROY_VPN);
112 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
113 }
114
115 HWTEST_F(NetworkVpnServiceStubTest, ReplyRegisterVpnEventTest001, TestSize.Level1)
116 {
117 NetManagerExtAccessToken token;
118 MessageParcel data;
119 if (!data.WriteInterfaceToken(NetworkVpnServiceStub::GetDescriptor())) {
120 return;
121 }
122 sptr<IVpnEventCallback> callback = new (std::nothrow) MockIVpnEventCallback();
123 if (!data.WriteRemoteObject(callback->AsObject())) {
124 return;
125 }
126 int32_t ret = SendRemoteRequest(data, INetworkVpnServiceIpcCode::COMMAND_REGISTER_VPN_EVENT);
127 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
128 }
129
130 HWTEST_F(NetworkVpnServiceStubTest, ReplyUnregisterVpnEventTest001, TestSize.Level1)
131 {
132 NetManagerExtAccessToken token;
133 MessageParcel data;
134 if (!data.WriteInterfaceToken(NetworkVpnServiceStub::GetDescriptor())) {
135 return;
136 }
137 sptr<IVpnEventCallback> callback = new (std::nothrow) MockIVpnEventCallback();
138 if (!data.WriteRemoteObject(callback->AsObject())) {
139 return;
140 }
141 int32_t ret = SendRemoteRequest(data, INetworkVpnServiceIpcCode::COMMAND_UNREGISTER_VPN_EVENT);
142 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
143 }
144
145 HWTEST_F(NetworkVpnServiceStubTest, ReplyCreateVpnConnectionTest001, TestSize.Level1)
146 {
147 NetManagerExtAccessToken token;
148 MessageParcel data;
149 if (!data.WriteInterfaceToken(NetworkVpnServiceStub::GetDescriptor())) {
150 return;
151 }
152 int32_t ret = SendRemoteRequest(data, INetworkVpnServiceIpcCode::COMMAND_CREATE_VPN_CONNECTION);
153 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
154 }
155
156 HWTEST_F(NetworkVpnServiceStubTest, ReplyRegisterSharingEventTest001, TestSize.Level1)
157 {
158 NetManagerExtAccessToken token;
159 MessageParcel data;
160 if (!data.WriteInterfaceToken(NetworkVpnServiceStub::GetDescriptor())) {
161 return;
162 }
163 sptr<IVpnEventCallback> callback = new (std::nothrow) MockIVpnEventCallback();
164 if (!data.WriteRemoteObject(callback->AsObject())) {
165 return;
166 }
167 int32_t ret = SendRemoteRequest(data, INetworkVpnServiceIpcCode::COMMAND_REGISTER_VPN_EVENT);
168 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
169 }
170
171 HWTEST_F(NetworkVpnServiceStubTest, ReplyUnregisterSharingEventTest001, TestSize.Level1)
172 {
173 NetManagerExtAccessToken token;
174 MessageParcel data;
175 if (!data.WriteInterfaceToken(NetworkVpnServiceStub::GetDescriptor())) {
176 return;
177 }
178 sptr<IVpnEventCallback> callback = new (std::nothrow) MockIVpnEventCallback();
179 if (!data.WriteRemoteObject(callback->AsObject())) {
180 return;
181 }
182 int32_t ret = SendRemoteRequest(data, INetworkVpnServiceIpcCode::COMMAND_UNREGISTER_VPN_EVENT);
183 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
184 }
185
186 HWTEST_F(NetworkVpnServiceStubTest, ReplyFactoryResetVpnTest001, TestSize.Level1)
187 {
188 MessageParcel data;
189 if (!data.WriteInterfaceToken(NetworkVpnServiceStub::GetDescriptor())) {
190 return;
191 }
192 int32_t ret = SendRemoteRequest(data, INetworkVpnServiceIpcCode::COMMAND_FACTORY_RESET_VPN);
193 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
194 }
195
196 HWTEST_F(NetworkVpnServiceStubTest, ReplyRegisterBundleNameVpnTest001, TestSize.Level1)
197 {
198 NetManagerExtAccessToken token;
199 MessageParcel data;
200 if (!data.WriteInterfaceToken(NetworkVpnServiceStub::GetDescriptor())) {
201 return;
202 }
203 sptr<IVpnEventCallback> callback = new (std::nothrow) MockIVpnEventCallback();
204 if (!data.WriteRemoteObject(callback->AsObject())) {
205 return;
206 }
207 int32_t ret = SendRemoteRequest(data, INetworkVpnServiceIpcCode::COMMAND_REGISTER_BUNDLE_NAME);
208 EXPECT_TRUE(ret == NETMANAGER_EXT_ERR_WRITE_REPLY_FAIL || ret == NETMANAGER_EXT_SUCCESS);
209 }
210
211 HWTEST_F(NetworkVpnServiceStubTest, ReplyDefaultTest001, TestSize.Level1)
212 {
213 NetManagerExtAccessToken token;
214 MessageParcel data;
215 if (!data.WriteInterfaceToken(NetworkVpnServiceStub::GetDescriptor())) {
216 return;
217 }
218 uint32_t code = static_cast<uint32_t>(INetworkVpnServiceIpcCode::COMMAND_REGISTER_BUNDLE_NAME) +
219 static_cast<uint32_t>(INetworkVpnServiceIpcCode::COMMAND_REGISTER_BUNDLE_NAME);
220 int32_t ret = SendRemoteRequest(data, static_cast<INetworkVpnServiceIpcCode>(code));
221 EXPECT_NE(ret, NETMANAGER_EXT_SUCCESS);
222 }
223 } // namespace NetManagerStandard
224 } // namespace OHOS
225