1 /*
2 * Copyright (c) 2023-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 #include <string>
18 #include <system_ability_definition.h>
19 #include <vector>
20
21 #include "edm_sys_manager_mock.h"
22 #include "enterprise_device_mgr_stub_mock.h"
23 #include "usb_device_id.h"
24 #include "usb_interface_type.h"
25 #include "usb_manager_proxy.h"
26 #include "utils.h"
27
28 using namespace testing::ext;
29 using namespace testing;
30
31 namespace OHOS {
32 namespace EDM {
33 namespace TEST {
34 const std::string ADMIN_PACKAGENAME = "com.edm.test.demo";
35 class UsbManagerProxyTest : public testing::Test {
36 protected:
37 void SetUp() override;
38
39 void TearDown() override;
40
41 static void TearDownTestSuite(void);
42 std::shared_ptr<UsbManagerProxy> proxy_ = nullptr;
43 std::shared_ptr<EdmSysManager> edmSysManager_ = nullptr;
44 sptr<EnterpriseDeviceMgrStubMock> object_ = nullptr;
45 };
46
SetUp()47 void UsbManagerProxyTest::SetUp()
48 {
49 proxy_ = UsbManagerProxy::GetUsbManagerProxy();
50 edmSysManager_ = std::make_shared<EdmSysManager>();
51 object_ = new (std::nothrow) EnterpriseDeviceMgrStubMock();
52 edmSysManager_->RegisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID, object_);
53 Utils::SetEdmServiceEnable();
54 }
55
TearDown()56 void UsbManagerProxyTest::TearDown()
57 {
58 proxy_.reset();
59 edmSysManager_->UnregisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID);
60 object_ = nullptr;
61 Utils::SetEdmServiceDisable();
62 }
63
TearDownTestSuite()64 void UsbManagerProxyTest::TearDownTestSuite()
65 {
66 ASSERT_FALSE(Utils::GetEdmServiceState());
67 std::cout << "EdmServiceState : " << Utils::GetEdmServiceState() << std::endl;
68 }
69
70 /**
71 * @tc.name: TestSetUsbReadOnlySuc
72 * @tc.desc: Test SetUsbReadOnly success func.
73 * @tc.type: FUNC
74 */
75 HWTEST_F(UsbManagerProxyTest, TestSetUsbReadOnlySuc, TestSize.Level1)
76 {
77 MessageParcel data;
78 OHOS::AppExecFwk::ElementName admin;
79 admin.SetBundleName(ADMIN_PACKAGENAME);
80 data.WriteParcelable(&admin);
81 data.WriteInt32(1);
82 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
83 .Times(1)
84 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
85
86 int32_t ret = proxy_->SetUsbReadOnly(data);
87 ASSERT_TRUE(ret == ERR_OK);
88 }
89
90 /**
91 * @tc.name: TestSetUsbReadOnlyFail
92 * @tc.desc: Test SetUsbReadOnly without enable edm service func.
93 * @tc.type: FUNC
94 */
95 HWTEST_F(UsbManagerProxyTest, TestSetUsbReadOnlyFail, TestSize.Level1)
96 {
97 Utils::SetEdmServiceDisable();
98 MessageParcel data;
99 OHOS::AppExecFwk::ElementName admin;
100 admin.SetBundleName(ADMIN_PACKAGENAME);
101 data.WriteParcelable(&admin);
102 data.WriteInt32(1);
103
104 int32_t ret = proxy_->SetUsbReadOnly(data);
105 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
106 }
107
108 /**
109 * @tc.name: TestDisableUsbSuc
110 * @tc.desc: Test DisableUsb success func.
111 * @tc.type: FUNC
112 */
113 HWTEST_F(UsbManagerProxyTest, TestDisableUsbSuc, TestSize.Level1)
114 {
115 MessageParcel data;
116 OHOS::AppExecFwk::ElementName admin;
117 admin.SetBundleName(ADMIN_PACKAGENAME);
118 data.WriteParcelable(&admin);
119 data.WriteBool(true);
120 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
121 .Times(1)
122 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
123
124 int32_t ret = proxy_->DisableUsb(data);
125 ASSERT_TRUE(ret == ERR_OK);
126 }
127
128 /**
129 * @tc.name: TestDisableUsbFail
130 * @tc.desc: Test DisableUsb without enable edm service func.
131 * @tc.type: FUNC
132 */
133 HWTEST_F(UsbManagerProxyTest, TestDisableUsbFail, TestSize.Level1)
134 {
135 Utils::SetEdmServiceDisable();
136 MessageParcel data;
137 OHOS::AppExecFwk::ElementName admin;
138 admin.SetBundleName(ADMIN_PACKAGENAME);
139 data.WriteParcelable(&admin);
140 data.WriteBool(true);
141
142 int32_t ret = proxy_->DisableUsb(data);
143 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
144 }
145
146 /**
147 * @tc.name: TestIsUsbDisabledSuc
148 * @tc.desc: Test IsUsbDisabled func.
149 * @tc.type: FUNC
150 */
151 HWTEST_F(UsbManagerProxyTest, TestIsUsbDisabledSuc, TestSize.Level1)
152 {
153 MessageParcel data;
154 OHOS::AppExecFwk::ElementName admin;
155 admin.SetBundleName(ADMIN_PACKAGENAME);
156 data.WriteParcelable(&admin);
157 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
158 .Times(1)
159 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeBoolSendRequestGetPolicy));
160
161 bool isDisable = false;
162 int32_t ret = proxy_->IsUsbDisabled(data, isDisable);
163 ASSERT_TRUE(ret == ERR_OK);
164 ASSERT_TRUE(isDisable);
165 }
166
167 /**
168 * @tc.name: TestIsUsbDisabledFail
169 * @tc.desc: Test IsUsbDisabled func without enable edm service.
170 * @tc.type: FUNC
171 */
172 HWTEST_F(UsbManagerProxyTest, TestIsUsbDisabledFail, TestSize.Level1)
173 {
174 Utils::SetEdmServiceDisable();
175 MessageParcel data;
176 OHOS::AppExecFwk::ElementName admin;
177 admin.SetBundleName(ADMIN_PACKAGENAME);
178 data.WriteParcelable(&admin);
179
180 bool isDisable = false;
181 int32_t ret = proxy_->IsUsbDisabled(data, isDisable);
182 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
183 ASSERT_FALSE(isDisable);
184 }
185
186 /**
187 * @tc.name: TestAddAllowedUsbDevicesSuc
188 * @tc.desc: Test AddAllowedUsbDevices success func.
189 * @tc.type: FUNC
190 */
191 HWTEST_F(UsbManagerProxyTest, TestAddAllowedUsbDevicesSuc, TestSize.Level1)
192 {
193 MessageParcel data;
194 OHOS::AppExecFwk::ElementName admin;
195 admin.SetBundleName(ADMIN_PACKAGENAME);
196 data.WriteParcelable(&admin);
197 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
198 .Times(1)
199 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
200 UsbDeviceId id1;
201 id1.SetVendorId(1);
202 id1.SetProductId(9);
203 data.WriteUint32(1);
204 id1.Marshalling(data);
205
206 int32_t ret = proxy_->AddAllowedUsbDevices(data);
207 ASSERT_TRUE(ret == ERR_OK);
208 }
209
210 /**
211 * @tc.name: TestAddAllowedUsbDevicesFail
212 * @tc.desc: Test AddAllowedUsbDevices without enable edm service func.
213 * @tc.type: FUNC
214 */
215 HWTEST_F(UsbManagerProxyTest, TestAddAllowedUsbDevicesFail, TestSize.Level1)
216 {
217 Utils::SetEdmServiceDisable();
218 MessageParcel data;
219 OHOS::AppExecFwk::ElementName admin;
220 admin.SetBundleName(ADMIN_PACKAGENAME);
221 data.WriteParcelable(&admin);
222 UsbDeviceId id1;
223 id1.SetVendorId(1);
224 id1.SetProductId(9);
225 data.WriteUint32(1);
226 id1.Marshalling(data);
227
228 int32_t ret = proxy_->AddAllowedUsbDevices(data);
229 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
230 }
231
232 /**
233 * @tc.name: TestRemoveAllowedUsbDevicesSuc
234 * @tc.desc: Test RemoveAllowedUsbDevices success func.
235 * @tc.type: FUNC
236 */
237 HWTEST_F(UsbManagerProxyTest, TestRemoveAllowedUsbDevicesSuc, TestSize.Level1)
238 {
239 MessageParcel data;
240 OHOS::AppExecFwk::ElementName admin;
241 admin.SetBundleName(ADMIN_PACKAGENAME);
242 data.WriteParcelable(&admin);
243 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
244 .Times(1)
245 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
246 UsbDeviceId id1;
247 id1.SetVendorId(1);
248 id1.SetProductId(9);
249 data.WriteUint32(1);
250 id1.Marshalling(data);
251
252 int32_t ret = proxy_->RemoveAllowedUsbDevices(data);
253 ASSERT_TRUE(ret == ERR_OK);
254 }
255
256 /**
257 * @tc.name: TestRemoveAllowedUsbDevicesFail
258 * @tc.desc: Test RemoveAllowedUsbDevices without enable edm service func.
259 * @tc.type: FUNC
260 */
261 HWTEST_F(UsbManagerProxyTest, TestRemoveAllowedUsbDevicesFail, TestSize.Level1)
262 {
263 Utils::SetEdmServiceDisable();
264 MessageParcel data;
265 OHOS::AppExecFwk::ElementName admin;
266 admin.SetBundleName(ADMIN_PACKAGENAME);
267 data.WriteParcelable(&admin);
268 UsbDeviceId id1;
269 id1.SetVendorId(1);
270 id1.SetProductId(9);
271 data.WriteUint32(1);
272 id1.Marshalling(data);
273
274 int32_t ret = proxy_->RemoveAllowedUsbDevices(data);
275 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
276 }
277
278 /**
279 * @tc.name: TestGetAllowedUsbDevicesSuc
280 * @tc.desc: Test GetAllowedUsbDevices func.
281 * @tc.type: FUNC
282 */
283 HWTEST_F(UsbManagerProxyTest, TestGetAllowedUsbDevicesSuc, TestSize.Level1)
284 {
285 MessageParcel data;
286 OHOS::AppExecFwk::ElementName admin;
287 admin.SetBundleName(ADMIN_PACKAGENAME);
288 data.WriteParcelable(&admin);
289 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
290 .Times(1)
291 .WillOnce(Invoke(object_.GetRefPtr(),
292 &EnterpriseDeviceMgrStubMock::InvokeAllowedUsbDevicesSendRequestGetPolicy));
293
294 std::vector<UsbDeviceId> usbDeviceIds;
295 int32_t ret = proxy_->GetAllowedUsbDevices(data, usbDeviceIds);
296 ASSERT_TRUE(ret == ERR_OK);
297 ASSERT_TRUE(usbDeviceIds.size() == 1);
298 }
299
300 /**
301 * @tc.name: TestGetAllowedUsbDevicesFail
302 * @tc.desc: Test GetAllowedUsbDevices func without enable edm service.
303 * @tc.type: FUNC
304 */
305 HWTEST_F(UsbManagerProxyTest, TestGetAllowedUsbDevicesFail, TestSize.Level1)
306 {
307 Utils::SetEdmServiceDisable();
308 MessageParcel data;
309 OHOS::AppExecFwk::ElementName admin;
310 admin.SetBundleName(ADMIN_PACKAGENAME);
311 data.WriteParcelable(&admin);
312
313 std::vector<UsbDeviceId> usbDeviceIds;
314 int32_t ret = proxy_->GetAllowedUsbDevices(data, usbDeviceIds);
315 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
316 ASSERT_TRUE(usbDeviceIds.empty());
317 }
318
319 /**
320 * @tc.name: TestSetUsbStorageDeviceAccessPolicySuc
321 * @tc.desc: Test SetUsbStorageDeviceAccessPolicy success func.
322 * @tc.type: FUNC
323 */
324 HWTEST_F(UsbManagerProxyTest, TestSetUsbStorageDeviceAccessPolicySuc, TestSize.Level1)
325 {
326 MessageParcel data;
327 OHOS::AppExecFwk::ElementName admin;
328 admin.SetBundleName(ADMIN_PACKAGENAME);
329 data.WriteParcelable(&admin);
330 data.WriteInt32(2);
331 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
332 .Times(1)
333 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
334 int32_t ret = proxy_->SetUsbStorageDeviceAccessPolicy(data);
335 ASSERT_TRUE(ret == ERR_OK);
336 }
337
338 /**
339 * @tc.name: TestSetUsbStorageDeviceAccessPolicyFail
340 * @tc.desc: Test SetUsbStorageDeviceAccessPolicy without enable edm service func.
341 * @tc.type: FUNC
342 */
343 HWTEST_F(UsbManagerProxyTest, TestSetUsbStorageDeviceAccessPolicyFail, TestSize.Level1)
344 {
345 Utils::SetEdmServiceDisable();
346 MessageParcel data;
347 OHOS::AppExecFwk::ElementName admin;
348 admin.SetBundleName(ADMIN_PACKAGENAME);
349 data.WriteParcelable(&admin);
350 data.WriteInt32(2);
351
352 int32_t ret = proxy_->SetUsbStorageDeviceAccessPolicy(data);
353 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
354 }
355
356 /**
357 * @tc.name: TestGetUsbStorageDeviceAccessPolicySuc
358 * @tc.desc: Test GetUsbStorageDeviceAccessPolicy func.
359 * @tc.type: FUNC
360 */
361 HWTEST_F(UsbManagerProxyTest, TestGetUsbStorageDeviceAccessPolicySuc, TestSize.Level1)
362 {
363 MessageParcel data;
364 OHOS::AppExecFwk::ElementName admin;
365 admin.SetBundleName(ADMIN_PACKAGENAME);
366 data.WriteParcelable(&admin);
367 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
368 .Times(1)
369 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeIntSendRequestGetPolicy));
370
371 int32_t policy = -1;
372 int32_t ret = proxy_->GetUsbStorageDeviceAccessPolicy(data, policy);
373 ASSERT_TRUE(ret == ERR_OK);
374 ASSERT_TRUE(policy == 0);
375 }
376
377 /**
378 * @tc.name: TestGetUsbStorageDeviceAccessPolicyFail
379 * @tc.desc: Test GetUsbStorageDeviceAccessPolicy func without enable edm service.
380 * @tc.type: FUNC
381 */
382 HWTEST_F(UsbManagerProxyTest, TestGetUsbStorageDeviceAccessPolicyFail, TestSize.Level1)
383 {
384 Utils::SetEdmServiceDisable();
385 MessageParcel data;
386 OHOS::AppExecFwk::ElementName admin;
387 admin.SetBundleName(ADMIN_PACKAGENAME);
388 data.WriteParcelable(&admin);
389
390 int32_t policy = 0;
391 int32_t ret = proxy_->GetUsbStorageDeviceAccessPolicy(data, policy);
392 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
393 }
394
395 /**
396 * @tc.name: TestAddOrRemoveDisallowedUsbDevicesAddSuc
397 * @tc.desc: Test AddOrRemoveDisallowedUsbDevices add success func.
398 * @tc.type: FUNC
399 */
400 HWTEST_F(UsbManagerProxyTest, TestAddOrRemoveDisallowedUsbDevicesAddSuc, TestSize.Level1)
401 {
402 MessageParcel data;
403 OHOS::AppExecFwk::ElementName admin;
404 admin.SetBundleName(ADMIN_PACKAGENAME);
405 data.WriteParcelable(&admin);
406 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
407 .Times(1)
408 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
409 USB::UsbDeviceType type;
410 type.baseClass = 3;
411 type.subClass = 1;
412 type.protocol = 2;
413 type.isDeviceType = false;
414 data.WriteUint32(1);
415 type.Marshalling(data);
416
417 int32_t ret = proxy_->AddOrRemoveDisallowedUsbDevices(data, true);
418 ASSERT_TRUE(ret == ERR_OK);
419 }
420
421 /**
422 * @tc.name: TestAddOrRemoveDisallowedUsbDevicesAddFail
423 * @tc.desc: Test AddOrRemoveDisallowedUsbDevices for adding without enable edm service func.
424 * @tc.type: FUNC
425 */
426 HWTEST_F(UsbManagerProxyTest, TestAddOrRemoveDisallowedUsbDevicesAddFail, TestSize.Level1)
427 {
428 Utils::SetEdmServiceDisable();
429 MessageParcel data;
430 OHOS::AppExecFwk::ElementName admin;
431 admin.SetBundleName(ADMIN_PACKAGENAME);
432 data.WriteParcelable(&admin);
433 USB::UsbDeviceType type;
434 type.baseClass = 3;
435 type.subClass = 1;
436 type.protocol = 2;
437 type.isDeviceType = false;
438 data.WriteUint32(1);
439 type.Marshalling(data);
440
441 int32_t ret = proxy_->AddOrRemoveDisallowedUsbDevices(data, true);
442 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
443 }
444
445 /**
446 * @tc.name: TestAddOrRemoveDisallowedUsbDevicesRemoveSuc
447 * @tc.desc: Test AddOrRemoveDisallowedUsbDevices remove success func.
448 * @tc.type: FUNC
449 */
450 HWTEST_F(UsbManagerProxyTest, TestAddOrRemoveDisallowedUsbDevicesRemoveSuc, TestSize.Level1)
451 {
452 MessageParcel data;
453 OHOS::AppExecFwk::ElementName admin;
454 admin.SetBundleName(ADMIN_PACKAGENAME);
455 data.WriteParcelable(&admin);
456 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
457 .Times(1)
458 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
459 USB::UsbDeviceType type;
460 type.baseClass = 3;
461 type.subClass = 1;
462 type.protocol = 2;
463 data.WriteUint32(1);
464 type.Marshalling(data);
465
466 int32_t ret = proxy_->AddOrRemoveDisallowedUsbDevices(data, false);
467 ASSERT_TRUE(ret == ERR_OK);
468 }
469
470 /**
471 * @tc.name: TestAddOrRemoveDisallowedUsbDevicesRemoveFail
472 * @tc.desc: Test AddOrRemoveDisallowedUsbDevices for removing without enable edm service func.
473 * @tc.type: FUNC
474 */
475 HWTEST_F(UsbManagerProxyTest, TestAddOrRemoveDisallowedUsbDevicesRemoveFail, TestSize.Level1)
476 {
477 Utils::SetEdmServiceDisable();
478 MessageParcel data;
479 OHOS::AppExecFwk::ElementName admin;
480 admin.SetBundleName(ADMIN_PACKAGENAME);
481 data.WriteParcelable(&admin);
482 USB::UsbDeviceType type;
483 type.baseClass = 3;
484 type.subClass = 1;
485 type.protocol = 2;
486 type.isDeviceType = false;
487 data.WriteUint32(1);
488 type.Marshalling(data);
489
490 int32_t ret = proxy_->AddOrRemoveDisallowedUsbDevices(data, false);
491 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
492 }
493
494 /**
495 * @tc.name: TestGetDisallowedUsbDevicesSuc
496 * @tc.desc: Test GetDisallowedUsbDevices func.
497 * @tc.type: FUNC
498 */
499 HWTEST_F(UsbManagerProxyTest, TestGetDisallowedUsbDevicesSuc, TestSize.Level1)
500 {
501 MessageParcel data;
502 OHOS::AppExecFwk::ElementName admin;
503 admin.SetBundleName(ADMIN_PACKAGENAME);
504 data.WriteParcelable(&admin);
505 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
506 .Times(1)
507 .WillOnce(Invoke(object_.GetRefPtr(),
508 &EnterpriseDeviceMgrStubMock::InvokeDisallowedUsbDevicesSendRequestGetPolicy));
509
510 std::vector<USB::UsbDeviceType> result;
511 int32_t ret = proxy_->GetDisallowedUsbDevices(data, result);
512 ASSERT_TRUE(ret == ERR_OK);
513 ASSERT_TRUE(result.size() == 1);
514 }
515
516 /**
517 * @tc.name: TestGetDisallowedUsbDevicesFail
518 * @tc.desc: Test GetDisallowedUsbDevices func without enable edm service.
519 * @tc.type: FUNC
520 */
521 HWTEST_F(UsbManagerProxyTest, TestGetDisallowedUsbDevicesFail, TestSize.Level1)
522 {
523 Utils::SetEdmServiceDisable();
524 MessageParcel data;
525 OHOS::AppExecFwk::ElementName admin;
526 admin.SetBundleName(ADMIN_PACKAGENAME);
527 data.WriteParcelable(&admin);
528
529 std::vector<USB::UsbDeviceType> result;
530 int32_t ret = proxy_->GetDisallowedUsbDevices(data, result);
531 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
532 ASSERT_TRUE(result.empty());
533 }
534 } // namespace TEST
535 } // namespace EDM
536 } // namespace OHOS
537