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 "UTTest_device_manager_service.h"
17 
18 #include "accesstoken_kit.h"
19 #include "dm_constants.h"
20 #include "dm_device_info.h"
21 #include "dm_log.h"
22 #include "nativetoken_kit.h"
23 #include "token_setproc.h"
24 #include "softbus_common.h"
25 #include "softbus_error_code.h"
26 
27 using namespace OHOS::Security::AccessToken;
28 namespace OHOS {
29 namespace DistributedHardware {
30 namespace {
DeletePermission()31 void DeletePermission()
32 {
33     const int32_t permsNum = 1;
34     const int32_t indexZero = 0;
35     uint64_t tokenId;
36     const char *perms[permsNum];
37     perms[indexZero] = "ohos.permission";
38     NativeTokenInfoParams infoInstance = {
39         .dcapsNum = 0,
40         .permsNum = permsNum,
41         .aclsNum = 0,
42         .dcaps = NULL,
43         .perms = perms,
44         .acls = NULL,
45         .processName = "DeviceManagerServiceTest",
46         .aplStr = "system_core",
47     };
48     tokenId = GetAccessTokenId(&infoInstance);
49     SetSelfTokenID(tokenId);
50     OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
51 }
52 
53 /**
54  * @tc.name: RegisterCallerAppId_201
55  * @tc.type: FUNC
56  */
57 HWTEST_F(DeviceManagerServiceTest, RegisterCallerAppId_201, testing::ext::TestSize.Level0)
58 {
59     std::string pkgName = "pkgName";
60     DeviceManagerService::GetInstance().listener_ = std::make_shared<DeviceManagerServiceListener>();
61     DeviceManagerService::GetInstance().RegisterCallerAppId(pkgName);
62     EXPECT_EQ(DeviceManagerService::GetInstance().listener_ != nullptr, true);
63 }
64 
65 /**
66  * @tc.name: GetTrustedDeviceList_201
67  * @tc.type: FUNC
68  */
69 HWTEST_F(DeviceManagerServiceTest, GetTrustedDeviceList_201, testing::ext::TestSize.Level0)
70 {
71     DeletePermission();
72     std::string pkgName = "pkgName";
73     const std::string extra;
74     std::vector<DmDeviceInfo> deviceList;
75     int32_t ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList);
76     EXPECT_EQ(ret, ERR_DM_POINT_NULL);
77 }
78 
79 /**
80  * @tc.name: GetDeviceInfo_201
81  * @tc.type: FUNC
82  */
83 HWTEST_F(DeviceManagerServiceTest, GetDeviceInfo_201, testing::ext::TestSize.Level0)
84 {
85     DeletePermission();
86     std::string networkId = "123";
87     DmDeviceInfo deviceIndo;
88     int32_t ret = DeviceManagerService::GetInstance().GetDeviceInfo(networkId, deviceIndo);
89     EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
90     ret = DeviceManagerService::GetInstance().GetLocalDeviceInfo(deviceIndo);
91     EXPECT_EQ(ret, ERR_DM_POINT_NULL);
92 }
93 
94 /**
95  * @tc.name: GetLocalDeviceInfo_201
96  * @tc.type: FUNC
97  */
98 HWTEST_F(DeviceManagerServiceTest, StopDeviceDiscovery_201, testing::ext::TestSize.Level0)
99 {
100     DeletePermission();
101     std::string pkgName = "pkgName";
102     uint16_t subscribeId = 111;
103     int32_t ret = DeviceManagerService::GetInstance().StopDeviceDiscovery(pkgName, subscribeId);
104     EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
105 }
106 
107 /**
108  * @tc.name: RegisterUiStateCallback_001
109  * @tc.type: FUNC
110  */
111 HWTEST_F(DeviceManagerServiceTest, RegisterUiStateCallback_201, testing::ext::TestSize.Level0)
112 {
113     DeletePermission();
114     std::string pkgName = "pkgName";
115     int32_t ret = DeviceManagerService::GetInstance().RegisterUiStateCallback(pkgName);
116     EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
117 }
118 
119 /**
120  * @tc.name: UnRegisterUiStateCallback_001
121  * @tc.type: FUNC
122  */
123 HWTEST_F(DeviceManagerServiceTest, UnRegisterUiStateCallback_201, testing::ext::TestSize.Level0)
124 {
125     DeletePermission();
126     std::string pkgName = "pkgName";
127     int32_t ret = DeviceManagerService::GetInstance().UnRegisterUiStateCallback(pkgName);
128     EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
129 }
130 
131 /**
132  * @tc.name: IsDMImplSoLoaded_001
133  * @tc.type: FUNC
134  */
135 HWTEST_F(DeviceManagerServiceTest, IsDMImplSoLoaded_201, testing::ext::TestSize.Level0)
136 {
137     std::string pkgName = "pkgName";
138     std::map<std::string, std::string> advertiseParam;
139     advertiseParam[PARAM_KEY_META_TYPE] = "1";
140     DeviceManagerService::GetInstance().StopAdvertising(pkgName, advertiseParam);
141     std::map<std::string, std::string> advertiseParam2;
142     advertiseParam[PARAM_KEY_PUBLISH_ID] = "12";
143     DeviceManagerService::GetInstance().StopAdvertising(pkgName, advertiseParam2);
144     PeerTargetId targetId;
145     targetId.deviceId = "123";
146     std::map<std::string, std::string> bindParam;
147     bindParam[PARAM_KEY_META_TYPE] = "1";
148     DeviceManagerService::GetInstance().BindTarget(pkgName, targetId, bindParam);
149     targetId.wifiIp = "192.168.1.1";
150     std::map<std::string, std::string> bindParam2;
151     DeviceManagerService::GetInstance().BindTarget(pkgName, targetId, bindParam2);
152     targetId.deviceId = "123";
153     std::map<std::string, std::string> unbindParam;
154     unbindParam[PARAM_KEY_META_TYPE] = "1";
155     DeviceManagerService::GetInstance().UnbindTarget(pkgName, targetId, unbindParam);
156     DeviceManagerService::GetInstance().IsDMServiceImplReady();
157     bool ret = DeviceManagerService::GetInstance().IsDMImplSoLoaded();
158     EXPECT_EQ(ret, true);
159 }
160 
161 /**
162  * @tc.name: RegisterPinHolderCallback_201
163  * @tc.type: FUNC
164  */
165 HWTEST_F(DeviceManagerServiceTest, RegisterPinHolderCallback_201, testing::ext::TestSize.Level0)
166 {
167     std::string pkgName = "CollaborationFwk";
168     int32_t ret = DeviceManagerService::GetInstance().RegisterPinHolderCallback(pkgName);
169     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
170 }
171 
172 /**
173  * @tc.name: CreatePinHolder_201
174  * @tc.type: FUNC
175  */
176 HWTEST_F(DeviceManagerServiceTest, CreatePinHolder_201, testing::ext::TestSize.Level0)
177 {
178     std::string pkgName = "CollaborationFwk";
179     PeerTargetId targetId;
180     DmPinType pinType = NUMBER_PIN_CODE;
181     std::string payload;
182     int32_t ret = DeviceManagerService::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
183     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
184 }
185 
186 /**
187  * @tc.name: GetDeviceSecurityLevel_201
188  * @tc.type: FUNC
189  */
190 HWTEST_F(DeviceManagerServiceTest, GetDeviceSecurityLevel_201, testing::ext::TestSize.Level0)
191 {
192     std::string pkgName = "pkgName";
193     std::string networkId = "123";
194     int32_t securityLevel;
195     DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
196     int32_t ret = DeviceManagerService::GetInstance().GetDeviceSecurityLevel(pkgName, networkId, securityLevel);
197     EXPECT_EQ(ret, ERR_DM_FAILED);
198 }
199 
200 /**
201  * @tc.name: CheckAccessControl_001
202  * @tc.type: FUNC
203  */
204 HWTEST_F(DeviceManagerServiceTest, CheckAccessControl_201, testing::ext::TestSize.Level0)
205 {
206     DmAccessCaller caller;
207     DmAccessCallee callee;
208     bool ret = DeviceManagerService::GetInstance().CheckAccessControl(caller, callee);
209     EXPECT_EQ(ret, true);
210 }
211 
212 /**
213  * @tc.name: CheckAccessControl_002
214  * @tc.type: FUNC
215  */
216 HWTEST_F(DeviceManagerServiceTest, CheckAccessControl_202, testing::ext::TestSize.Level0)
217 {
218     DmAccessCaller caller;
219     DmAccessCallee callee;
220     DeletePermission();
221     bool ret = DeviceManagerService::GetInstance().CheckAccessControl(caller, callee);
222     EXPECT_EQ(ret, true);
223 }
224 
225 /**
226  * @tc.name: CheckIsSameAccount_201
227  * @tc.type: FUNC
228  */
229 HWTEST_F(DeviceManagerServiceTest, CheckIsSameAccount_201, testing::ext::TestSize.Level0)
230 {
231     DmAccessCaller caller;
232     DmAccessCallee callee;
233     bool ret = DeviceManagerService::GetInstance().CheckIsSameAccount(caller, callee);
234     EXPECT_EQ(ret, true);
235 }
236 
237 /**
238  * @tc.name: CheckIsSameAccount_202
239  * @tc.type: FUNC
240  */
241 HWTEST_F(DeviceManagerServiceTest, CheckIsSameAccount_202, testing::ext::TestSize.Level0)
242 {
243     DmAccessCaller caller;
244     DmAccessCallee callee;
245     DeletePermission();
246     bool ret = DeviceManagerService::GetInstance().CheckIsSameAccount(caller, callee);
247     EXPECT_EQ(ret, true);
248 }
249 
250 /**
251  * @tc.name: InitAccountInfo_201
252  * @tc.type: FUNC
253  */
254 HWTEST_F(DeviceManagerServiceTest, InitAccountInfo_201, testing::ext::TestSize.Level0)
255 {
256     int32_t userId = 100;
257     std::string commonEventType = "usual.event.USER_SWITCHED";
258     DeviceManagerService::GetInstance().AccountCommonEventCallback(userId, commonEventType);
259     commonEventType = "common.event.HWID_LOGIN";
260     DeviceManagerService::GetInstance().AccountCommonEventCallback(userId, commonEventType);
261     int32_t ret = DeviceManagerService::GetInstance().InitAccountInfo();
262     EXPECT_EQ(ret, DM_OK);
263 }
264 
265 /**
266  * @tc.name: InitScreenLockEvent_001
267  * @tc.type: FUNC
268  */
269 HWTEST_F(DeviceManagerServiceTest, InitScreenLockEvent_201, testing::ext::TestSize.Level0)
270 {
271     int32_t ret = DeviceManagerService::GetInstance().InitScreenLockEvent();
272     EXPECT_EQ(ret, DM_OK);
273 }
274 
275 /**
276  * @tc.name: SubscribeAccountCommonEvent_201
277  * @tc.type: FUNC
278  */
279 HWTEST_F(DeviceManagerServiceTest, SubscribeAccountCommonEvent_201, testing::ext::TestSize.Level0)
280 {
281     DeviceManagerService::GetInstance().SubscribeAccountCommonEvent();
282     DeviceManagerService::GetInstance().SubscribeScreenLockEvent();
283     std::string commonEventType = "usual.event.USER_SWITCHED";
284     DeviceManagerService::GetInstance().ScreenCommonEventCallback(commonEventType);
285     EXPECT_NE(DeviceManagerService::GetInstance().accountCommonEventManager_, nullptr);
286 }
287 
288 /**
289  * @tc.name: SetDnPolicy_201
290  * @tc.type: FUNC
291  */
292 HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_201, testing::ext::TestSize.Level0)
293 {
294     std::string packName = "com.ohos.test";
295     std::map<std::string, std::string> policy;
296     policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100";
297     policy[PARAM_KEY_POLICY_TIME_OUT] = "10";
298     int32_t ret = DeviceManagerService::GetInstance().SetDnPolicy(packName, policy);
299     bool bRet = false;
300     if (ret == DM_OK || ret == ERR_DM_UNSUPPORTED_METHOD) {
301         bRet = true;
302     }
303     ASSERT_EQ(bRet, true);
304 }
305 
306 /**
307  * @tc.name: SetDnPolicy_202
308  * @tc.type: FUNC
309  */
310 HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_202, testing::ext::TestSize.Level0)
311 {
312     std::string packName;
313     std::map<std::string, std::string> policy;
314     policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100";
315     policy[PARAM_KEY_POLICY_TIME_OUT] = "10";
316     int32_t ret = DeviceManagerService::GetInstance().SetDnPolicy(packName, policy);
317     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
318 }
319 
320 /**
321  * @tc.name: SetDnPolicy_203
322  * @tc.type: FUNC
323  */
324 HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_203, testing::ext::TestSize.Level0)
325 {
326     std::string packName = "com.ohos.test";
327     std::map<std::string, std::string> policy;
328     policy[PARAM_KEY_POLICY_TIME_OUT] = "10";
329     int32_t ret = DeviceManagerService::GetInstance().SetDnPolicy(packName, policy);
330     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
331 }
332 
333 /**
334  * @tc.name: SetDnPolicy_204
335  * @tc.type: FUNC
336  */
337 HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_204, testing::ext::TestSize.Level0)
338 {
339     std::string packName = "com.ohos.test";
340     std::map<std::string, std::string> policy;
341     policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100";
342     int32_t ret = DeviceManagerService::GetInstance().SetDnPolicy(packName, policy);
343     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
344 }
345 
346 /**
347  * @tc.name: SetDnPolicy_205
348  * @tc.type: FUNC
349  */
350 HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_205, testing::ext::TestSize.Level0)
351 {
352     std::string packName = "com.ohos.test";
353     std::map<std::string, std::string> policy;
354     policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "a100";
355     policy[PARAM_KEY_POLICY_TIME_OUT] = "10";
356     int32_t ret = DeviceManagerService::GetInstance().SetDnPolicy(packName, policy);
357     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
358 }
359 
360 /**
361  * @tc.name: SetDnPolicy_206
362  * @tc.type: FUNC
363  */
364 HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_206, testing::ext::TestSize.Level0)
365 {
366     std::string packName = "com.ohos.test";
367     std::map<std::string, std::string> policy;
368     policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100a";
369     policy[PARAM_KEY_POLICY_TIME_OUT] = "10";
370     int32_t ret = DeviceManagerService::GetInstance().SetDnPolicy(packName, policy);
371     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
372 }
373 
374 HWTEST_F(DeviceManagerServiceTest, GetDeviceScreenStatus_201, testing::ext::TestSize.Level0)
375 {
376     std::string pkgName = "com.ohos.screenStatusTest";
377     std::string networkId = "";
378     int32_t screenStatus = -1;
379     int32_t ret = DeviceManagerService::GetInstance().GetDeviceScreenStatus(pkgName, networkId, screenStatus);
380     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
381 }
382 
383 HWTEST_F(DeviceManagerServiceTest, GetDeviceScreenStatus_202, testing::ext::TestSize.Level0)
384 {
385     std::string pkgName = "";
386     std::string networkId = "networkIdTest";
387     int32_t screenStatus = -1;
388     int32_t ret = DeviceManagerService::GetInstance().GetDeviceScreenStatus(pkgName, networkId, screenStatus);
389     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
390 }
391 } // namespace
392 } // namespace DistributedHardware
393 } // namespace OHOS