1 /*
2 * Copyright (c) 2022 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 "test_util.h"
19 #include "utils.h"
20
21 #define protected public
22 #define private public
23 #include "authority_manager.h"
24 #include "device_manager.h"
25 #include "dp_device_manager.h"
26 #include "sync_coordinator.h"
27 #include "trust_group_manager.h"
28 #undef private
29 #undef protected
30 #include "device_profile_errors.h"
31
32 namespace OHOS {
33 namespace DeviceProfile {
34 using namespace testing;
35 using namespace testing::ext;
36 using namespace DistributedHardware;
37
38 namespace {
39 const std::string AUTHORITY_JSON_PATH = "/system/etc/deviceprofile/authority.json";
40 const std::string TEST_DEVICEID = "1111111111111111111111111";
41 const std::string TEST_TRUST_GROUP =
42 "{\"groupId\":\"id\",\"groupType\":0,\"groupName\":\"name\",\"groupOwner\":\"test\",\"groupVisibility\":1}";
43 const std::string TEST_TRUST_GROUPS =
44 "[{\"groupId\":\"id\",\"groupType\":0,\"groupName\":\"name\",\"groupOwner\":\"test\",\"groupVisibility\":1}]";
45 const std::string TEST_TRUST_GROUPS_VISIABLE =
46 "[{\"groupId\":\"id\",\"groupType\":0,\"groupName\":\"name\",\"groupOwner\":\"test\",\"groupVisibility\":-1}]";
47 const std::string TEST_TRUST_GROUPS_SAMEACCOUNT =
48 "[{\"groupId\":\"id\",\"groupType\":256,\"groupName\":\"name\",\"groupOwner\":\"test\",\"groupVisibility\":-1}]";
49 const std::string TEST_TRUST_GROUP_EMPTY = "{}";
50 const std::string TEST_TRUST_GROUPS_EMPTY = "[{}]";
51 const std::string INVALID_AUTHORITY_STR =
52 "{\"fakeProcess1\":{\"servicesAuthority\":{\"all\":3}},\"fakeProcess2\":{\"servicesAuthority\":{\"all\":true}}}";
53 const std::string VALID_AUTHORITY_STR = "{\"hdcd\":{\"servicesAuthority\":{\"all\":1,\"specific\":" \
54 "{\"storage\":3,\"system\":3},\"prefix\":{\"cameraRear\":3}},\"interfacesAuthority\":{\"sync\":{}}}}";
55 const std::string PKG_NAME = "DBinderBus_" + std::to_string(getpid());
56 const std::string INVALID_INTERFACE_SERVICE = "{\"invalidinterface\":\"invalid\"";
57 const std::string INVALID_INTERFACE_VALUE = "{\"interfacesAuthority\":\"invalid\"";
58 const std::string INVALID_SERVIES_SPE = "{\"specific\":{\"storage\":\"3\"}}";
59 const std::string INVALID_SERVIES_PRE = "{\"prefix\":{\"storage\":\"3\"}}";
60 const std::string EMPTY_INTERFACE_VALUE = "{\"interfacesAuthority\":\"\"";
61 const std::string EMPTY_AUTHORITY_STR = "{\"distributedsched\":\"\"";
62 }
63
64 class ProfileAuthorityTest : public testing::Test {
65 public:
66 static void SetUpTestCase();
67 static void TearDownTestCase();
68 static bool LoadAuthorityCfg(const std::string& filePath);
69 static bool LoadAuthorityByStr(const std::string& jsonStr);
70 void SetUp();
71 void TearDown();
72 class DeviceInitCallBack : public DistributedHardware::DmInitCallback {
73 void OnRemoteDied() override;
74 };
75 };
76
OnRemoteDied()77 void ProfileAuthorityTest::DeviceInitCallBack::OnRemoteDied()
78 {
79 }
80
SetUpTestCase()81 void ProfileAuthorityTest::SetUpTestCase()
82 {
83 }
84
TearDownTestCase()85 void ProfileAuthorityTest::TearDownTestCase()
86 {
87 }
88
SetUp()89 void ProfileAuthorityTest::SetUp()
90 {
91 }
92
TearDown()93 void ProfileAuthorityTest::TearDown()
94 {
95 }
96
LoadAuthorityCfg(const std::string & filePath)97 bool ProfileAuthorityTest::LoadAuthorityCfg(const std::string& filePath)
98 {
99 if (!AuthorityManager::GetInstance().LoadAuthorityCfg(filePath)) {
100 DTEST_LOG << "not found " << filePath << std::endl;
101 return false;
102 }
103 AuthorityManager::GetInstance().InitSupportedInterfaces();
104 AuthorityManager::GetInstance().ValidateAuthorityCfg();
105 return true;
106 }
107
LoadAuthorityByStr(const std::string & jsonStr)108 bool ProfileAuthorityTest::LoadAuthorityByStr(const std::string& jsonStr)
109 {
110 AuthorityManager::GetInstance().authJson_ =
111 nlohmann::json::parse(jsonStr.c_str(), nullptr, false);
112 if (AuthorityManager::GetInstance().authJson_.is_discarded()) {
113 return false;
114 }
115
116 AuthorityManager::GetInstance().InitSupportedInterfaces();
117 AuthorityManager::GetInstance().ValidateAuthorityCfg();
118 return true;
119 }
120
121 /**
122 * @tc.name: PrecheckAuthority_001
123 * @tc.desc: precheck an authority json with invalid config
124 * @tc.type: FUNC
125 * @tc.require: I4OH94
126 */
127 HWTEST_F(ProfileAuthorityTest, PrecheckAuthority_001, TestSize.Level2)
128 {
129 if (!LoadAuthorityByStr(INVALID_AUTHORITY_STR)) {
130 return;
131 }
132
133 EXPECT_EQ(AuthorityManager::GetInstance().authJson_.dump(), R"({})");
134 }
135
136 /**
137 * @tc.name: CheckAuthority_002
138 * @tc.desc: check authority of a fake serviceId
139 * @tc.type: FUNC
140 * @tc.require: I4OH94
141 */
142 HWTEST_F(ProfileAuthorityTest, CheckAuthority_002, TestSize.Level2)
143 {
144 if (!LoadAuthorityByStr(VALID_AUTHORITY_STR)) {
145 return;
146 }
147
148 EXPECT_EQ(false, AuthorityManager::GetInstance().CheckServiceAuthority(AuthValue::AUTH_W,
149 "fakeServiceId"));
150 }
151
152 /**
153 * @tc.name: CheckAuthority_003
154 * @tc.desc: check authority of specific serviceId with diff auth value
155 * @tc.type: FUNC
156 * @tc.require: I4OH94
157 */
158 HWTEST_F(ProfileAuthorityTest, CheckAuthority_003, TestSize.Level2)
159 {
160 if (!LoadAuthorityByStr(VALID_AUTHORITY_STR)) {
161 return;
162 }
163
164 EXPECT_EQ(true, AuthorityManager::GetInstance().CheckServiceAuthority(AuthValue::AUTH_R, "storage"));
165 EXPECT_EQ(true, AuthorityManager::GetInstance().CheckServiceAuthority(AuthValue::AUTH_W, "storage"));
166 }
167
168 /**
169 * @tc.name: CheckAuthority_004
170 * @tc.desc: check authority of an empty serviceId
171 * @tc.type: FUNC
172 * @tc.require: I4OH94
173 */
174 HWTEST_F(ProfileAuthorityTest, CheckAuthority_004, TestSize.Level2)
175 {
176 if (!LoadAuthorityByStr(VALID_AUTHORITY_STR)) {
177 return;
178 }
179
180 EXPECT_EQ(false, AuthorityManager::GetInstance().CheckServiceAuthority(AuthValue::AUTH_R,
181 ""));
182 EXPECT_EQ(false, AuthorityManager::GetInstance().CheckServicesAuthority(AuthValue::AUTH_R,
183 {"system", ""}));
184 }
185
186 /**
187 * @tc.name: CheckAuthority_005
188 * @tc.desc: check authority of all with diff auth value
189 * @tc.type: FUNC
190 * @tc.require: I4OH94
191 */
192 HWTEST_F(ProfileAuthorityTest, CheckAuthority_005, TestSize.Level2)
193 {
194 if (!LoadAuthorityByStr(VALID_AUTHORITY_STR)) {
195 return;
196 }
197
198 EXPECT_EQ(true, AuthorityManager::GetInstance().CheckServicesAuthority(AuthValue::AUTH_R, {}));
199 EXPECT_EQ(false, AuthorityManager::GetInstance().CheckServicesAuthority(AuthValue::AUTH_W, {}));
200 }
201
202 /**
203 * @tc.name: CheckAuthority_006
204 * @tc.desc: check authority of serviceIds with same prefix
205 * @tc.type: FUNC
206 * @tc.require: I4OH94
207 */
208 HWTEST_F(ProfileAuthorityTest, CheckAuthority_006, TestSize.Level2)
209 {
210 if (!LoadAuthorityByStr(VALID_AUTHORITY_STR)) {
211 return;
212 }
213
214 EXPECT_EQ(true, AuthorityManager::GetInstance().CheckServiceAuthority(AuthValue::AUTH_R,
215 "cameraRear1"));
216 EXPECT_EQ(true, AuthorityManager::GetInstance().CheckServiceAuthority(AuthValue::AUTH_W,
217 "cameraRear1"));
218
219 EXPECT_EQ(true, AuthorityManager::GetInstance().CheckServiceAuthority(AuthValue::AUTH_R,
220 "cameraRear2"));
221 EXPECT_EQ(true, AuthorityManager::GetInstance().CheckServiceAuthority(AuthValue::AUTH_W,
222 "cameraRear2"));
223 }
224
225 /**
226 * @tc.name: CheckAuthority_007
227 * @tc.desc: check authority of multiple serviceIds
228 * @tc.type: FUNC
229 * @tc.require: I4OH94
230 */
231 HWTEST_F(ProfileAuthorityTest, CheckAuthority_007, TestSize.Level2)
232 {
233 if (!LoadAuthorityByStr(VALID_AUTHORITY_STR)) {
234 return;
235 }
236
237 EXPECT_EQ(true, AuthorityManager::GetInstance().CheckServicesAuthority(AuthValue::AUTH_W,
238 {"cameraRear1", "cameraRear2", "cameraRear3"}));
239 EXPECT_EQ(true, AuthorityManager::GetInstance().CheckServicesAuthority(AuthValue::AUTH_W,
240 {"storage", "system"}));
241 EXPECT_EQ(true, AuthorityManager::GetInstance().CheckServicesAuthority(AuthValue::AUTH_W,
242 {"cameraRear1", "cameraRear2", "cameraRear3", "storage", "system"}));
243
244 if (!LoadAuthorityByStr(INVALID_AUTHORITY_STR)) {
245 return;
246 }
247 EXPECT_EQ(false, AuthorityManager::GetInstance().CheckServicesAuthority(AuthValue::AUTH_W,
248 {"storage", "system"}));
249 }
250
251 /**
252 * @tc.name: CheckAuthority_008
253 * @tc.desc: check authority of interfaces
254 * @tc.type: FUNC
255 * @tc.require: I4OH94
256 */
257 HWTEST_F(ProfileAuthorityTest, CheckAuthority_008, TestSize.Level2)
258 {
259 if (!LoadAuthorityByStr(VALID_AUTHORITY_STR)) {
260 return;
261 }
262
263 EXPECT_EQ(true, AuthorityManager::GetInstance().CheckInterfaceAuthority("sync"));
264 EXPECT_EQ(false, AuthorityManager::GetInstance().CheckInterfaceAuthority("fakeInterface"));
265 EXPECT_EQ(false, AuthorityManager::GetInstance().CheckInterfaceAuthority(""));
266
267 if (!LoadAuthorityByStr(INVALID_AUTHORITY_STR)) {
268 return;
269 }
270 EXPECT_EQ(false, AuthorityManager::GetInstance().CheckInterfaceAuthority("sync"));
271 }
272
273 /**
274 * @tc.name: CheckAuthority_009
275 * @tc.desc: check authority of interfaces
276 * @tc.type: FUNC
277 * @tc.require: I4OH94
278 */
279 HWTEST_F(ProfileAuthorityTest, CheckAuthority_009, TestSize.Level2)
280 {
281 if (!LoadAuthorityCfg(AUTHORITY_JSON_PATH)) {
282 return;
283 }
284
285 EXPECT_EQ(false, AuthorityManager::GetInstance().CheckServiceAuthority(AuthValue::AUTH_R, "syscap"));
286 }
287
288 /**
289 * @tc.name: CheckAuthority_0010
290 * @tc.desc: check authority of interfaces
291 * @tc.type: FUNC
292 * @tc.require: I4OH94
293 */
294 HWTEST_F(ProfileAuthorityTest, CheckAuthority_0010, TestSize.Level2)
295 {
296 nlohmann::json jsonObject = nlohmann::json::parse(INVALID_INTERFACE_SERVICE, nullptr, false);
297 if (jsonObject.is_discarded()) {
298 return;
299 }
300
301 EXPECT_EQ(false, AuthorityManager::GetInstance().ValidateProcess(jsonObject));
302 }
303
304 /**
305 * @tc.name: CheckAuthority_0011
306 * @tc.desc: check authority of interfaces
307 * @tc.type: FUNC
308 * @tc.require: I4OH94
309 */
310 HWTEST_F(ProfileAuthorityTest, CheckAuthority_0011, TestSize.Level2)
311 {
312 nlohmann::json jsonObject = nlohmann::json::parse(INVALID_INTERFACE_VALUE, nullptr, false);
313 if (jsonObject.is_discarded()) {
314 return;
315 }
316
317 EXPECT_EQ(false, AuthorityManager::GetInstance().ValidateProcess(jsonObject));
318 EXPECT_EQ(false, AuthorityManager::GetInstance().ValidateInterfaces(jsonObject));
319
320 jsonObject = nlohmann::json::parse(EMPTY_INTERFACE_VALUE, nullptr, false);
321 if (jsonObject.is_discarded()) {
322 return;
323 }
324 EXPECT_EQ(false, AuthorityManager::GetInstance().ValidateInterfaces(jsonObject));
325 }
326
327 /**
328 * @tc.name: CheckAuthority_0012
329 * @tc.desc: check authority of interfaces
330 * @tc.type: FUNC
331 * @tc.require: I4OH94
332 */
333 HWTEST_F(ProfileAuthorityTest, CheckAuthority_0012, TestSize.Level2)
334 {
335 nlohmann::json jsonObject = nlohmann::json::parse(TEST_TRUST_GROUP_EMPTY, nullptr, false);
336 if (jsonObject.is_discarded()) {
337 return;
338 }
339 EXPECT_EQ(false, AuthorityManager::GetInstance().ValidateServices(jsonObject));
340 EXPECT_EQ(false, AuthorityManager::GetInstance().ValidateInterfaces(jsonObject));
341
342 jsonObject = nlohmann::json::parse(INVALID_SERVIES_SPE, nullptr, false);
343 if (jsonObject.is_discarded()) {
344 return;
345 }
346 EXPECT_EQ(false, AuthorityManager::GetInstance().ValidateServices(jsonObject));
347
348 jsonObject = nlohmann::json::parse(INVALID_SERVIES_PRE, nullptr, false);
349 if (jsonObject.is_discarded()) {
350 return;
351 }
352 EXPECT_EQ(false, AuthorityManager::GetInstance().ValidateServices(jsonObject));
353 }
354
355 /**
356 * @tc.name: Init_001
357 * @tc.desc: precheck an authority json with invalid config
358 * @tc.type: FUNC
359 * @tc.require: I4OH94
360 */
361 HWTEST_F(ProfileAuthorityTest, Init_001, TestSize.Level2)
362 {
363 EXPECT_EQ(true, AuthorityManager::GetInstance().Init());
364 }
365
366 /**
367 * @tc.name: CheckDeviceId_001
368 * @tc.desc: check device id of interfaces
369 * @tc.type: FUNC
370 * @tc.require: I4OH93
371 */
372 HWTEST_F(ProfileAuthorityTest, CheckDeviceId_001, TestSize.Level2)
373 {
374 EXPECT_EQ(false, TrustGroupManager::GetInstance().CheckDeviceId(""));
375 EXPECT_EQ(true, TrustGroupManager::GetInstance().CheckDeviceId(TEST_DEVICEID));
376 }
377
378 /**
379 * @tc.name: InitHichainService_001
380 * @tc.desc: init hichain service of interfaces
381 * @tc.type: FUNC
382 * @tc.require: I4OH93
383 */
384 HWTEST_F(ProfileAuthorityTest, InitHichainService_001, TestSize.Level2)
385 {
386 TrustGroupManager::GetInstance().OnDeviceUnBoundAdapter("", "");
387
388 std::string localDeviceId;
389 DpDeviceManager::GetInstance().GetLocalDeviceUdid(localDeviceId);
390 TrustGroupManager::GetInstance().OnDeviceUnBoundAdapter(localDeviceId.c_str(), "");
391 EXPECT_EQ(true, TrustGroupManager::GetInstance().InitHichainService());
392 }
393
394 /**
395 * @tc.name: CheckTrustGroup_001
396 * @tc.desc: check trust group of interfaces
397 * @tc.type: FUNC
398 * @tc.require: I4OH93
399 */
400 HWTEST_F(ProfileAuthorityTest, CheckTrustGroup_001, TestSize.Level2)
401 {
402 GroupInfo groupInfo;
403 nlohmann::json jsonObject = nlohmann::json::parse(TEST_TRUST_GROUP, nullptr, false);
404 if (jsonObject.is_discarded()) {
405 return;
406 }
407 from_json(jsonObject, groupInfo);
408 EXPECT_EQ(false, TrustGroupManager::GetInstance().CheckTrustGroup(""));
409 }
410
411 /**
412 * @tc.name: CheckTrustGroup_002
413 * @tc.desc: check trust group of interfaces
414 * @tc.type: FUNC
415 * @tc.require: I4OH93
416 */
417 HWTEST_F(ProfileAuthorityTest, CheckTrustGroup_002, TestSize.Level2)
418 {
419 GroupInfo groupInfo;
420 nlohmann::json jsonObject = nlohmann::json::parse(TEST_TRUST_GROUP_EMPTY, nullptr, false);
421 if (jsonObject.is_discarded()) {
422 return;
423 }
424 from_json(jsonObject, groupInfo);
425 EXPECT_EQ(false, TrustGroupManager::GetInstance().CheckTrustGroup(""));
426 }
427
428 /**
429 * @tc.name: InitHichainService_002
430 * @tc.desc: init hichain service of interfaces
431 * @tc.type: FUNC
432 * @tc.require: I4OH93
433 */
434 HWTEST_F(ProfileAuthorityTest, InitHichainService_002, TestSize.Level2)
435 {
436 std::string localDeviceId;
437 std::shared_ptr<DistributedHardware::DmInitCallback> initCallback_ =
438 std::make_shared<DeviceInitCallBack>();
439 DeviceManager::GetInstance().InitDeviceManager(PKG_NAME, initCallback_);
440 DpDeviceManager::GetInstance().GetLocalDeviceUdid(localDeviceId);
441 TrustGroupManager::GetInstance().OnDeviceUnBoundAdapter(localDeviceId.c_str(), "");
442 EXPECT_EQ(true, TrustGroupManager::GetInstance().InitHichainService());
443 }
444
445 /**
446 * @tc.name: CheckCallerTrust_001
447 * @tc.desc: init hichain service of interfaces
448 * @tc.type: FUNC
449 * @tc.require: I4OH93
450 */
451 HWTEST_F(ProfileAuthorityTest, CheckCallerTrust_001, TestSize.Level2)
452 {
453 TestUtil::MockInvalidTokenID();
454 bool res = AuthorityManager::GetInstance().CheckCallerTrust();
455 EXPECT_EQ(false, res);
456 }
457
458 /**
459 * @tc.name: CheckCallerTrust_002
460 * @tc.desc: init hichain service of interfaces
461 * @tc.type: FUNC
462 * @tc.require: I4OH93
463 */
464 HWTEST_F(ProfileAuthorityTest, CheckCallerTrust_002, TestSize.Level2)
465 {
466 TestUtil::MockPermission("distributedsched");
467 bool res = AuthorityManager::GetInstance().CheckCallerTrust();
468 EXPECT_EQ(true, res);
469 }
470
471 /**
472 * @tc.name: CheckInterfaceAuthority_001
473 * @tc.desc: init hichain service of interfaces
474 * @tc.type: FUNC
475 * @tc.require: I4OH93
476 */
477 HWTEST_F(ProfileAuthorityTest, CheckInterfaceAuthority_001, TestSize.Level2)
478 {
479 AuthorityManager::GetInstance().authJson_.clear();
480 bool res = AuthorityManager::GetInstance().CheckInterfaceAuthority("");
481 EXPECT_EQ(false, res);
482 }
483
484 /**
485 * @tc.name: CheckTrustGroup_003
486 * @tc.desc: check trust group of interfaces
487 * @tc.type: FUNC
488 * @tc.require: I4OH93
489 */
490 HWTEST_F(ProfileAuthorityTest, CheckTrustGroup_003, TestSize.Level3)
491 {
492 EXPECT_EQ(false, TrustGroupManager::GetInstance().CheckGroupsInfo(TEST_TRUST_GROUPS.c_str(), 0));
493 EXPECT_EQ(false, TrustGroupManager::GetInstance().CheckGroupsInfo(TEST_TRUST_GROUPS.c_str(), 1));
494 }
495
496 /**
497 * @tc.name: CheckTrustGroup_004
498 * @tc.desc: check trust group of interfaces
499 * @tc.type: FUNC
500 * @tc.require: I4OH93
501 */
502 HWTEST_F(ProfileAuthorityTest, CheckTrustGroup_004, TestSize.Level3)
503 {
504 EXPECT_EQ(false, TrustGroupManager::GetInstance().CheckGroupsInfo(TEST_TRUST_GROUPS_EMPTY.c_str(), 1));
505 }
506
507 /**
508 * @tc.name: CheckTrustGroup_005
509 * @tc.desc: check trust group of interfaces
510 * @tc.type: FUNC
511 * @tc.require: I4OH93
512 */
513 HWTEST_F(ProfileAuthorityTest, CheckTrustGroup_005, TestSize.Level3)
514 {
515 EXPECT_EQ(false, TrustGroupManager::GetInstance().CheckGroupsInfo(TEST_TRUST_GROUPS_VISIABLE.c_str(), 1));
516 EXPECT_EQ(true, TrustGroupManager::GetInstance().CheckGroupsInfo(TEST_TRUST_GROUPS_SAMEACCOUNT.c_str(), 1));
517 EXPECT_EQ(false, TrustGroupManager::GetInstance().CheckGroupsInfo(AUTHORITY_JSON_PATH.c_str(), 1));
518 }
519 }
520 }
521