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