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 "device_manager_adapter.h"
17 #include "gtest/gtest.h"
18 #include "accesstoken_kit.h"
19 #include "executor_pool.h"
20 #include "nativetoken_kit.h"
21 #include "token_setproc.h"
22 #include "types.h"
23 namespace {
24 using namespace testing::ext;
25 using namespace OHOS::AppDistributedKv;
26 using namespace OHOS::DistributedData;
27 using namespace OHOS::DistributedHardware;
28 using namespace OHOS::Security::AccessToken;
29 using DmDeviceInfo =  OHOS::DistributedHardware::DmDeviceInfo;
30 class DeviceChangerListener final : public AppDeviceChangeListener {
31 public:
OnDeviceChanged(const DeviceInfo & info,const DeviceChangeType & type) const32     void OnDeviceChanged(const DeviceInfo &info, const DeviceChangeType &type) const override
33     {
34     }
GetChangeLevelType() const35     ChangeLevelType GetChangeLevelType() const override
36     {
37         return ChangeLevelType::MIN;
38     }
39 };
40 
GrantPermissionNative()41 void GrantPermissionNative()
42 {
43     const char **perms = new const char *[2];
44     perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
45     perms[1] = "ohos.permission.ACCESS_SERVICE_DM";
46     TokenInfoParams infoInstance = {
47         .dcapsNum = 0,
48         .permsNum = 2,
49         .aclsNum = 0,
50         .dcaps = nullptr,
51         .perms = perms,
52         .acls = nullptr,
53         .processName = "distributed_data_test",
54         .aplStr = "system_basic",
55     };
56     uint64_t tokenId = GetAccessTokenId(&infoInstance);
57     SetSelfTokenID(tokenId);
58     AccessTokenKit::ReloadNativeTokenInfo();
59     delete []perms;
60 }
61 
62 class DeviceManagerAdapterTest : public testing::Test {
63 public:
SetUpTestCase(void)64   static void SetUpTestCase(void)
65     {
66         size_t max = 12;
67         size_t min = 5;
68         GrantPermissionNative();
69         DeviceManagerAdapter::GetInstance().Init(std::make_shared<OHOS::ExecutorPool>(max, min));
70     }
TearDownTestCase(void)71     static void TearDownTestCase(void) {}
SetUp()72     void SetUp() {}
TearDown()73     void TearDown() {}
74 
75 protected:
76     static std::shared_ptr<DeviceChangerListener> observer_;
77     static const std::string INVALID_DEVICE_ID;
78     static const std::string EMPTY_DEVICE_ID;
79     static const uint32_t LOCAL_DEVICE_ID_NUM;
80     static const uint32_t LOCAL_UUID_NUM;
81 };
82 std::shared_ptr<DeviceChangerListener> DeviceManagerAdapterTest::observer_;
83 const std::string DeviceManagerAdapterTest::INVALID_DEVICE_ID = "1234567890";
84 const std::string DeviceManagerAdapterTest::EMPTY_DEVICE_ID = "";
85 const uint32_t DeviceManagerAdapterTest::LOCAL_DEVICE_ID_NUM = 3;
86 const uint32_t DeviceManagerAdapterTest::LOCAL_UUID_NUM = 2;
87 
88 /**
89 * @tc.name: StartWatchDeviceChange
90 * @tc.desc: start watch device change
91 * @tc.type: FUNC
92 * @tc.require:
93 * @tc.author: zuojiangjiang
94  */
95 HWTEST_F(DeviceManagerAdapterTest, StartWatchDeviceChange, TestSize.Level0)
96 {
97     auto status = DeviceManagerAdapter::GetInstance().StartWatchDeviceChange(nullptr, {});
98     EXPECT_EQ(status, Status::INVALID_ARGUMENT);
99     observer_ = std::make_shared<DeviceChangerListener>();
100     status = DeviceManagerAdapter::GetInstance().StartWatchDeviceChange(observer_.get(), {});
101     EXPECT_EQ(status, Status::SUCCESS);
102     status = DeviceManagerAdapter::GetInstance().StartWatchDeviceChange(observer_.get(), {});
103     EXPECT_EQ(status, Status::ERROR);
104 }
105 
106 /**
107 * @tc.name: StopWatchDeviceChange
108 * @tc.desc: stop watch device change, the observer is nullptr
109 * @tc.type: FUNC
110 * @tc.require:
111 * @tc.author: zuojiangjiang
112  */
113 HWTEST_F(DeviceManagerAdapterTest, StopWatchDeviceChange, TestSize.Level0)
114 {
115     auto status = DeviceManagerAdapter::GetInstance().StopWatchDeviceChange(nullptr, {});
116     EXPECT_EQ(status, Status::INVALID_ARGUMENT);
117     status = DeviceManagerAdapter::GetInstance().StopWatchDeviceChange(observer_.get(), {});
118     EXPECT_EQ(status, Status::SUCCESS);
119     status = DeviceManagerAdapter::GetInstance().StopWatchDeviceChange(observer_.get(), {});
120     EXPECT_EQ(status, Status::ERROR);
121     observer_ = nullptr;
122 }
123 
124 /**
125 * @tc.name: StopWatchDeviceChange002
126 * @tc.desc: stop watch device change, the observer is not register
127 * @tc.type: FUNC
128 * @tc.require:
129 * @tc.author: zuojiangjiang
130  */
131 HWTEST_F(DeviceManagerAdapterTest, StopWatchDeviceChangeNotRegister, TestSize.Level0)
132 {
133     std::shared_ptr<DeviceChangerListener> observer = std::make_shared<DeviceChangerListener>();
134     auto status = DeviceManagerAdapter::GetInstance().StopWatchDeviceChange(observer.get(), {});
135     EXPECT_EQ(status, Status::ERROR);
136 }
137 
138 /**
139 * @tc.name: GetLocalDevice
140 * @tc.desc: get local device
141 * @tc.type: FUNC
142 * @tc.require:
143 * @tc.author: zuojiangjiang
144  */
145 HWTEST_F(DeviceManagerAdapterTest, GetLocalDevice, TestSize.Level0)
146 {
147     auto dvInfo = DeviceManagerAdapter::GetInstance().GetLocalDevice();
148     EXPECT_FALSE(dvInfo.uuid.empty());
149     EXPECT_FALSE(dvInfo.udid.empty());
150     EXPECT_FALSE(dvInfo.networkId.empty());
151 }
152 
153 /**
154 * @tc.name: GetRemoteDevices
155 * @tc.desc: get remote device
156 * @tc.type: FUNC
157 * @tc.require:
158 * @tc.author: zuojiangjiang
159  */
160 HWTEST_F(DeviceManagerAdapterTest, GetRemoteDevices, TestSize.Level0)
161 {
162     auto dvInfos = DeviceManagerAdapter::GetInstance().GetRemoteDevices();
163     EXPECT_TRUE(dvInfos.empty());
164 }
165 
166 /**
167 * @tc.name: GetDeviceInfo
168 * @tc.desc: get device info, the id is invalid
169 * @tc.type: FUNC
170 * @tc.require:
171 * @tc.author: zuojiangjiang
172  */
173 HWTEST_F(DeviceManagerAdapterTest, GetDeviceInfoInvalidId, TestSize.Level0)
174 {
175     auto dvInfo = DeviceManagerAdapter::GetInstance().GetDeviceInfo(EMPTY_DEVICE_ID);
176     EXPECT_TRUE(dvInfo.udid.empty());
177     dvInfo = DeviceManagerAdapter::GetInstance().GetDeviceInfo(INVALID_DEVICE_ID);
178     EXPECT_TRUE(dvInfo.udid.empty());
179 }
180 
181 /**
182 * @tc.name: GetDeviceInfo
183 * @tc.desc: get device info, the id is local deviceId
184 * @tc.type: FUNC
185 * @tc.require:
186 * @tc.author: zuojiangjiang
187  */
188 HWTEST_F(DeviceManagerAdapterTest, GetDeviceInfoLocalId, TestSize.Level0)
189 {
190     auto localDvInfo = DeviceManagerAdapter::GetInstance().GetLocalDevice();
191     auto uuidToDVInfo = DeviceManagerAdapter::GetInstance().GetDeviceInfo(localDvInfo.uuid);
192     EXPECT_EQ(localDvInfo.udid, uuidToDVInfo.udid);
193     auto udidToDVInfo = DeviceManagerAdapter::GetInstance().GetDeviceInfo(localDvInfo.udid);
194     EXPECT_EQ(localDvInfo.uuid, udidToDVInfo.uuid);
195     auto networkIdToDVInfo = DeviceManagerAdapter::GetInstance().GetDeviceInfo(localDvInfo.networkId);
196     EXPECT_EQ(localDvInfo.udid, networkIdToDVInfo.udid);
197 }
198 
199 /**
200 * @tc.name: GetUuidByNetworkId
201 * @tc.desc: get uuid by networkId, the networkId is invalid
202 * @tc.type: FUNC
203 * @tc.require:
204 * @tc.author: zuojiangjiang
205  */
206 HWTEST_F(DeviceManagerAdapterTest, GetUuidByNetworkIdInvalid, TestSize.Level0)
207 {
208     auto uuid = DeviceManagerAdapter::GetInstance().GetUuidByNetworkId(EMPTY_DEVICE_ID);
209     EXPECT_TRUE(uuid.empty());
210     uuid = DeviceManagerAdapter::GetInstance().GetUuidByNetworkId(INVALID_DEVICE_ID);
211     EXPECT_TRUE(uuid.empty());
212 }
213 
214 /**
215 * @tc.name: GetUuidByNetworkId
216 * @tc.desc: get uuid by networkId, the networkId is local networkId
217 * @tc.type: FUNC
218 * @tc.require:
219 * @tc.author: zuojiangjiang
220  */
221 HWTEST_F(DeviceManagerAdapterTest, GetUuidByNetworkIdLocal, TestSize.Level0)
222 {
223     auto dvInfo = DeviceManagerAdapter::GetInstance().GetLocalDevice();
224     auto uuid = DeviceManagerAdapter::GetInstance().GetUuidByNetworkId(dvInfo.networkId);
225     EXPECT_EQ(uuid, dvInfo.uuid);
226 }
227 
228 /**
229 * @tc.name: GetUdidByNetworkId
230 * @tc.desc: get udid by networkId, the networkId is invalid
231 * @tc.type: FUNC
232 * @tc.require:
233 * @tc.author: zuojiangjiang
234  */
235 HWTEST_F(DeviceManagerAdapterTest, GetUdidByNetworkIdInvalid, TestSize.Level0)
236 {
237     auto udid = DeviceManagerAdapter::GetInstance().GetUdidByNetworkId(EMPTY_DEVICE_ID);
238     EXPECT_TRUE(udid.empty());
239     udid = DeviceManagerAdapter::GetInstance().GetUdidByNetworkId(INVALID_DEVICE_ID);
240     EXPECT_TRUE(udid.empty());
241 }
242 
243 /**
244 * @tc.name: GetUdidByNetworkId
245 * @tc.desc: get udid by networkId, the networkId is local networkId
246 * @tc.type: FUNC
247 * @tc.require:
248 * @tc.author: zuojiangjiang
249  */
250 HWTEST_F(DeviceManagerAdapterTest, GetUdidByNetworkIdLocal, TestSize.Level0)
251 {
252     auto dvInfo = DeviceManagerAdapter::GetInstance().GetLocalDevice();
253     auto udid = DeviceManagerAdapter::GetInstance().GetUdidByNetworkId(dvInfo.networkId);
254     EXPECT_EQ(udid, dvInfo.udid);
255 }
256 
257 /**
258 * @tc.name: DeviceIdToUUID
259 * @tc.desc: transfer deviceId to uuid, the deviceId is invalid
260 * @tc.type: FUNC
261 * @tc.require:
262 * @tc.author: zuojiangjiang
263  */
264 HWTEST_F(DeviceManagerAdapterTest, DeviceIdToUUIDInvalid, TestSize.Level0)
265 {
266     auto uuid = DeviceManagerAdapter::GetInstance().ToUUID(EMPTY_DEVICE_ID);
267     EXPECT_TRUE(uuid.empty());
268     uuid = DeviceManagerAdapter::GetInstance().ToUUID(INVALID_DEVICE_ID);
269     EXPECT_TRUE(uuid.empty());
270 }
271 
272 /**
273 * @tc.name: DeviceIdToUUID
274 * @tc.desc: transfer deviceId to uuid, the deviceId is local deviceId
275 * @tc.type: FUNC
276 * @tc.require:
277 * @tc.author: zuojiangjiang
278  */
279 HWTEST_F(DeviceManagerAdapterTest, DeviceIdToUUIDLocal, TestSize.Level0)
280 {
281     auto dvInfo = DeviceManagerAdapter::GetInstance().GetLocalDevice();
282     auto uuidToUuid = DeviceManagerAdapter::GetInstance().ToUUID(dvInfo.uuid);
283     EXPECT_EQ(uuidToUuid, dvInfo.uuid);
284     auto udidToUuid = DeviceManagerAdapter::GetInstance().ToUUID(dvInfo.udid);
285     EXPECT_EQ(udidToUuid, dvInfo.uuid);
286     auto networkIdToUuid = DeviceManagerAdapter::GetInstance().ToUUID(dvInfo.networkId);
287     EXPECT_EQ(networkIdToUuid, dvInfo.uuid);
288 }
289 
290 /**
291 * @tc.name: DeviceIdToUUID
292 * @tc.desc: transfer deviceIds to uuid
293 * @tc.type: FUNC
294 * @tc.require:
295 * @tc.author: zuojiangjiang
296  */
297 HWTEST_F(DeviceManagerAdapterTest, DeviceIdsToUUID, TestSize.Level0)
298 {
299     std::vector<std::string> devices;
300     devices.emplace_back(EMPTY_DEVICE_ID);
301     devices.emplace_back(INVALID_DEVICE_ID);
302     auto dvInfo = DeviceManagerAdapter::GetInstance().GetLocalDevice();
303     devices.emplace_back(dvInfo.uuid);
304     devices.emplace_back(dvInfo.udid);
305     devices.emplace_back(dvInfo.networkId);
306     auto uuids = DeviceManagerAdapter::GetInstance().ToUUID(devices);
307     EXPECT_EQ(uuids.size(), LOCAL_DEVICE_ID_NUM);
308     for (const auto &uuid : uuids) {
309         EXPECT_EQ(uuid, dvInfo.uuid);
310     }
311 }
312 
313 /**
314 * @tc.name: DeviceIdToUUID
315 * @tc.desc: transfer deviceIds to uuid
316 * @tc.type: FUNC
317 * @tc.require:
318 * @tc.author: zuojiangjiang
319  */
320 HWTEST_F(DeviceManagerAdapterTest, DeviceIdToUUID, TestSize.Level0)
321 {
322     std::vector<DeviceInfo> devices;
323     DeviceInfo dvInfo;
324     devices.emplace_back(dvInfo);
325     dvInfo.uuid = INVALID_DEVICE_ID;
326     devices.emplace_back(dvInfo);
327     dvInfo = DeviceManagerAdapter::GetInstance().GetLocalDevice();
328     devices.emplace_back(dvInfo);
329     auto uuids = DeviceManagerAdapter::GetInstance().ToUUID(devices);
330     EXPECT_EQ(uuids.size(), LOCAL_UUID_NUM);
331     EXPECT_EQ(uuids[0], INVALID_DEVICE_ID);
332     EXPECT_EQ(uuids[1], dvInfo.uuid);
333 }
334 
335 /**
336 * @tc.name: DeviceIdToNetworkId
337 * @tc.desc: transfer deviceId to networkId, the deviceId is invalid
338 * @tc.type: FUNC
339 * @tc.require:
340 * @tc.author: zuojiangjiang
341  */
342 HWTEST_F(DeviceManagerAdapterTest, DeviceIdToNetworkIdInvalid, TestSize.Level0)
343 {
344     auto networkId = DeviceManagerAdapter::GetInstance().ToNetworkID(EMPTY_DEVICE_ID);
345     EXPECT_TRUE(networkId.empty());
346     networkId = DeviceManagerAdapter::GetInstance().ToNetworkID(INVALID_DEVICE_ID);
347     EXPECT_TRUE(networkId.empty());
348 }
349 
350 /**
351 * @tc.name: DeviceIdToNetworkId
352 * @tc.desc: transfer deviceId to networkId, the deviceId is local deviceId
353 * @tc.type: FUNC
354 * @tc.require:
355 * @tc.author: zuojiangjiang
356  */
357 HWTEST_F(DeviceManagerAdapterTest, DeviceIdToNetworkIdLocal, TestSize.Level0)
358 {
359     auto dvInfo = DeviceManagerAdapter::GetInstance().GetLocalDevice();
360     auto uuidToNetworkId = DeviceManagerAdapter::GetInstance().ToNetworkID(dvInfo.uuid);
361     EXPECT_EQ(uuidToNetworkId, dvInfo.networkId);
362     auto udidToNetworkId = DeviceManagerAdapter::GetInstance().ToNetworkID(dvInfo.udid);
363     EXPECT_EQ(udidToNetworkId, dvInfo.networkId);
364     auto networkIdToNetworkId = DeviceManagerAdapter::GetInstance().ToNetworkID(dvInfo.networkId);
365     EXPECT_EQ(networkIdToNetworkId, dvInfo.networkId);
366 }
367 
368 /**
369 * @tc.name: StartWatchDeviceChange
370 * @tc.desc: start watch device change
371 * @tc.type: FUNC
372 * @tc.author: nhj
373  */
374 HWTEST_F(DeviceManagerAdapterTest, StartWatchDeviceChange01, TestSize.Level0)
375 {
376     std::shared_ptr<DeviceChangerListener> observer = std::make_shared<DeviceChangerListener>();
377     auto status = DeviceManagerAdapter::GetInstance().StartWatchDeviceChange(observer.get(), {});
378     EXPECT_EQ(status, Status::SUCCESS);
379 }
380 
381 /**
382 * @tc.name: GetDeviceInfo
383 * @tc.desc: get device info
384 * @tc.type: FUNC
385 * @tc.author: nhj
386  */
387 HWTEST_F(DeviceManagerAdapterTest, GetDeviceInfo, TestSize.Level0)
388 {
389     auto executors = std::make_shared<OHOS::ExecutorPool>(0, 0);
390     DeviceManagerAdapter::GetInstance().Init(executors);
391     auto dvInfo = DeviceManagerAdapter::GetInstance().GetDeviceInfo(EMPTY_DEVICE_ID);
392     EXPECT_TRUE(dvInfo.uuid.empty());
393     EXPECT_TRUE(dvInfo.udid.empty());
394     EXPECT_TRUE(dvInfo.networkId.empty());
395 }
396 
397 /**
398 * @tc.name: GetDeviceInfo
399 * @tc.desc: get device info, the id is invalid
400 * @tc.type: FUNC
401 * @tc.author: nhj
402  */
403 HWTEST_F(DeviceManagerAdapterTest, GetDeviceInfoInvalidId01, TestSize.Level0)
404 {
405     auto dvInfo = DeviceManagerAdapter::GetInstance().GetDeviceInfo(EMPTY_DEVICE_ID);
406     EXPECT_TRUE(dvInfo.uuid.empty());
407 }
408 
409 /**
410 * @tc.name: GetOnlineDevices
411 * @tc.desc: get Online device
412 * @tc.type: FUNC
413 * @tc.author: nhj
414  */
415 HWTEST_F(DeviceManagerAdapterTest, GetOnlineDevices, TestSize.Level0)
416 {
417     auto onInfos = DeviceManagerAdapter::GetInstance().GetOnlineDevices();
418     EXPECT_TRUE(onInfos.empty());
419 }
420 
421 } // namespace