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 "UTTest_device_manager_service_impl.h"
17
18 namespace OHOS {
19 namespace DistributedHardware {
SetUp()20 void DeviceManagerServiceImplTest::SetUp()
21 {
22 }
23
TearDown()24 void DeviceManagerServiceImplTest::TearDown()
25 {
26 }
27
SetUpTestCase()28 void DeviceManagerServiceImplTest::SetUpTestCase()
29 {
30 }
31
TearDownTestCase()32 void DeviceManagerServiceImplTest::TearDownTestCase()
33 {
34 }
35
36 namespace {
37 std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
38 std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
39 std::shared_ptr<HiChainConnector> hiChainConnector_ = std::make_shared<HiChainConnector>();
40
41 /**
42 * @tc.name: Initialize_001
43 * @tc.desc: return DM_OK
44 * @tc.type: FUNC
45 */
46 HWTEST_F(DeviceManagerServiceImplTest, Initialize_001, testing::ext::TestSize.Level0)
47 {
48 auto ideviceManagerServiceListener = std::shared_ptr<IDeviceManagerServiceListener>();
49 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>
50 ();
51 deviceManagerServiceImpl->commonEventManager_ = std::make_shared<DmCommonEventManager>();
52 int ret = deviceManagerServiceImpl->Initialize(ideviceManagerServiceListener);
53 EXPECT_EQ(ret, DM_OK);
54 }
55
56 /**
57 * @tc.name: Initialize_001
58 * @tc.desc: return DM_OK
59 * @tc.type: FUNC
60 */
61 HWTEST_F(DeviceManagerServiceImplTest, Initialize_002, testing::ext::TestSize.Level0)
62 {
63 auto ideviceManagerServiceListener = std::shared_ptr<IDeviceManagerServiceListener>();
64 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>
65 ();
66 deviceManagerServiceImpl->commonEventManager_ = nullptr;
67 int ret = deviceManagerServiceImpl->Initialize(ideviceManagerServiceListener);
68 EXPECT_EQ(ret, DM_OK);
69 }
70
71 /**
72 * @tc.name: RegisterDevStateCallback_001
73 * @tc.desc: return DM_OK
74 * @tc.type: FUNC
75 */
76 HWTEST_F(DeviceManagerServiceImplTest, RegisterDevStateCallback_001, testing::ext::TestSize.Level0)
77 {
78 std::string pkgName = "com.ohos.test";
79 std::string extra;
80 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
81 int32_t ret = deviceManagerServiceImpl->RegisterDevStateCallback(pkgName, extra);
82 EXPECT_EQ(ret, DM_OK);
83 }
84
85 /**
86 * @tc.name: RegisterDevStateCallback_002
87 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
88 * @tc.type: FUNC
89 */
90 HWTEST_F(DeviceManagerServiceImplTest, RegisterDevStateCallback_002, testing::ext::TestSize.Level0)
91 {
92 std::string pkgName;
93 std::string extra;
94 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
95 int32_t ret = deviceManagerServiceImpl->RegisterDevStateCallback(pkgName, extra);
96 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
97 }
98
99 /**
100 * @tc.name: RegisterDevStateCallback_003
101 * @tc.desc: return DM_OK
102 * @tc.type: FUNC
103 */
104 HWTEST_F(DeviceManagerServiceImplTest, RegisterDevStateCallback_003, testing::ext::TestSize.Level0)
105 {
106 std::string pkgName = "com.ohos.test";
107 std::string extra = "extraTest";
108 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
109 deviceManagerServiceImpl->deviceStateMgr_ =
110 std::make_shared<DmDeviceStateManager>(softbusConnector, listener, hiChainConnector_);
111 int32_t ret = deviceManagerServiceImpl->RegisterDevStateCallback(pkgName, extra);
112 EXPECT_EQ(ret, DM_OK);
113 }
114
115 /**
116 * @tc.name: PraseNotifyEventJson_001
117 * @tc.desc: return ERR_DM_FAILED
118 * @tc.type: FUNC
119 */
120 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_001, testing::ext::TestSize.Level0)
121 {
122 std::string event = R"({"extra": {"deviceId": "123"})";
123 nlohmann::json jsonObject;
124 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
125 int ret = deviceManagerServiceImpl->PraseNotifyEventJson(event, jsonObject);
126 EXPECT_EQ(ret, ERR_DM_FAILED);
127 }
128
129 /**
130 * @tc.name: PraseNotifyEventJson_002
131 * @tc.desc: return ERR_DM_FAILED
132 * @tc.type: FUNC
133 */
134 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_002, testing::ext::TestSize.Level0)
135 {
136 std::string event = R"({"content": {"deviceid": "123"}})";
137 nlohmann::json jsonObject;
138 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
139 int ret = deviceManagerServiceImpl->PraseNotifyEventJson(event, jsonObject);
140 EXPECT_EQ(ret, ERR_DM_FAILED);
141 }
142
143 /**
144 * @tc.name: PraseNotifyEventJson_003
145 * @tc.desc: return ERR_DM_FAILED
146 * @tc.type: FUNC
147 */
148 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_003, testing::ext::TestSize.Level0)
149 {
150 std::string event = R"({"extra": {"deviceaId": "123"}})";
151 nlohmann::json jsonObject;
152 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
153 int ret = deviceManagerServiceImpl->PraseNotifyEventJson(event, jsonObject);
154 EXPECT_EQ(ret, ERR_DM_FAILED);
155 }
156
157 /**
158 * @tc.name: PraseNotifyEventJson_004
159 * @tc.desc: return ERR_DM_FAILED
160 * @tc.type: FUNC
161 */
162 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_004, testing::ext::TestSize.Level0)
163 {
164 std::string event = R"({"extra": {"deviceId": 123}})";
165 nlohmann::json jsonObject;
166 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
167 int ret = deviceManagerServiceImpl->PraseNotifyEventJson(event, jsonObject);
168 EXPECT_EQ(ret, ERR_DM_FAILED);
169 }
170
171 /**
172 * @tc.name: PraseNotifyEventJson_005
173 * @tc.desc: return ERR_DM_FAILED
174 * @tc.type: FUNC
175 */
176 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_005, testing::ext::TestSize.Level0)
177 {
178 std::string event = R"({"Extra": {"deviceId": "123"}})";
179 nlohmann::json jsonObject;
180 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
181 int ret = deviceManagerServiceImpl->PraseNotifyEventJson(event, jsonObject);
182 EXPECT_EQ(ret, ERR_DM_FAILED);
183 }
184
185 /**
186 * @tc.name: PraseNotifyEventJson_006
187 * @tc.desc: return ERR_DM_FAILED
188 * @tc.type: FUNC
189 */
190 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_006, testing::ext::TestSize.Level0)
191 {
192 std::string event = R"({"extra":"123"}})";
193 nlohmann::json jsonObject;
194 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
195 int ret = deviceManagerServiceImpl->PraseNotifyEventJson(event, jsonObject);
196 EXPECT_EQ(ret, ERR_DM_FAILED);
197 }
198
199 /**
200 * @tc.name: PraseNotifyEventJson_007
201 * @tc.desc: return DM_OK
202 * @tc.type: FUNC
203 */
204 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_007, testing::ext::TestSize.Level0)
205 {
206 std::string event = R"({"extra": {"deviceId": "123"}})";
207 nlohmann::json jsonObject;
208 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
209 int ret = deviceManagerServiceImpl->PraseNotifyEventJson(event, jsonObject);
210 EXPECT_EQ(ret, DM_OK);
211 }
212
213 /**
214 * @tc.name: NotifyEvent_001
215 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
216 * @tc.type: FUNC
217 */
218 HWTEST_F(DeviceManagerServiceImplTest, NotifyEvent_001, testing::ext::TestSize.Level0)
219 {
220 std::string pkgName = "com.ohos.test";
221 int32_t eventId = DM_NOTIFY_EVENT_START;
222 std::string event = R"({"extra": {"deviceId": "123"}})";
223 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
224 int ret = deviceManagerServiceImpl->NotifyEvent(pkgName, eventId, event);
225 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
226 }
227
228 /**
229 * @tc.name: NotifyEvent_002
230 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
231 * @tc.type: FUNC
232 */
233 HWTEST_F(DeviceManagerServiceImplTest, NotifyEvent_002, testing::ext::TestSize.Level0)
234 {
235 std::string pkgName = "com.ohos.test";
236 int32_t eventId = DM_NOTIFY_EVENT_BUTT;
237 std::string event = R"({"extra": {"deviceId": "123"}})";
238 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
239 int ret = deviceManagerServiceImpl->NotifyEvent(pkgName, eventId, event);
240 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
241 }
242
243 /**
244 * @tc.name: NotifyEvent_003
245 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
246 * @tc.type: FUNC
247 */
248 HWTEST_F(DeviceManagerServiceImplTest, NotifyEvent_003, testing::ext::TestSize.Level0)
249 {
250 std::string pkgName = "com.ohos.test";
251 int32_t eventId = DM_NOTIFY_EVENT_ONDEVICEREADY;
252 std::string event = R"({"extra": {"deviceId": "123"})";
253 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
254 int ret = deviceManagerServiceImpl->NotifyEvent(pkgName, eventId, event);
255 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
256 }
257
258 /**
259 * @tc.name: RequestCredential_001
260 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
261 * @tc.type: FUNC
262 */
263 HWTEST_F(DeviceManagerServiceImplTest, RequestCredential_001, testing::ext::TestSize.Level0)
264 {
265 const std::string reqJsonStr = "";
266 std::string returnJsonStr = "returnTest";
267 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
268 int32_t ret = deviceManagerServiceImpl->RequestCredential(reqJsonStr, returnJsonStr);
269 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
270 }
271
272 /**
273 * @tc.name: RequestCredential_002
274 * @tc.desc: return ERR_DM_POINT_NULL
275 * @tc.type: FUNC
276 */
277 HWTEST_F(DeviceManagerServiceImplTest, RequestCredential_002, testing::ext::TestSize.Level0)
278 {
279 const std::string reqJsonStr = "test";
280 std::string returnJsonStr = "returnTest";
281 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
282 deviceManagerServiceImpl->credentialMgr_ = nullptr;
283 int32_t ret = deviceManagerServiceImpl->RequestCredential(reqJsonStr, returnJsonStr);
284 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
285 }
286
287 /**
288 * @tc.name: ImportCredential_001
289 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
290 * @tc.type: FUNC
291 */
292 HWTEST_F(DeviceManagerServiceImplTest, ImportCredential_001, testing::ext::TestSize.Level0)
293 {
294 const std::string pkgName = "";
295 const std::string credentialInfo = "";
296 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
297 int32_t ret = deviceManagerServiceImpl->ImportCredential(pkgName, credentialInfo);
298 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
299 }
300
301 /**
302 * @tc.name: ImportCredential_002
303 * @tc.desc: return ERR_DM_POINT_NULL
304 * @tc.type: FUNC
305 */
306 HWTEST_F(DeviceManagerServiceImplTest, ImportCredential_002, testing::ext::TestSize.Level0)
307 {
308 const std::string pkgName = "pkgNameTest";
309 const std::string credentialInfo = "credentialInfoTest";
310 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
311 deviceManagerServiceImpl->credentialMgr_ = nullptr;
312 int32_t ret = deviceManagerServiceImpl->ImportCredential(pkgName, credentialInfo);
313 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
314 }
315
316 /**
317 * @tc.name: DeleteCredential_001
318 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
319 * @tc.type: FUNC
320 */
321 HWTEST_F(DeviceManagerServiceImplTest, DeleteCredential_001, testing::ext::TestSize.Level0)
322 {
323 const std::string pkgName = "";
324 const std::string deleteInfo = "";
325 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
326 int32_t ret = deviceManagerServiceImpl->DeleteCredential(pkgName, deleteInfo);
327 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
328 }
329
330 /**
331 * @tc.name: DeleteCredential_002
332 * @tc.desc: return ERR_DM_POINT_NULL
333 * @tc.type: FUNC
334 */
335 HWTEST_F(DeviceManagerServiceImplTest, DeleteCredential_002, testing::ext::TestSize.Level0)
336 {
337 const std::string pkgName = "pkgNameTest";
338 const std::string deleteInfo = "deleteInfoTest";
339 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
340 deviceManagerServiceImpl->credentialMgr_ = nullptr;
341 int32_t ret = deviceManagerServiceImpl->DeleteCredential(pkgName, deleteInfo);
342 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
343 }
344
345 /**
346 * @tc.name: RegisterCredentialCallback_001
347 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
348 * @tc.type: FUNC
349 */
350 HWTEST_F(DeviceManagerServiceImplTest, RegisterCredentialCallback_001, testing::ext::TestSize.Level0)
351 {
352 const std::string pkgName = "";
353 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
354 int32_t ret = deviceManagerServiceImpl->RegisterCredentialCallback(pkgName);
355 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
356 }
357
358 /**
359 * @tc.name: RegisterCredentialCallback_002
360 * @tc.desc: return ERR_DM_POINT_NULL
361 * @tc.type: FUNC
362 */
363 HWTEST_F(DeviceManagerServiceImplTest, RegisterCredentialCallback_002, testing::ext::TestSize.Level0)
364 {
365 const std::string pkgName = "pkgNameTest";
366 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
367 deviceManagerServiceImpl->credentialMgr_ = nullptr;
368 int32_t ret = deviceManagerServiceImpl->RegisterCredentialCallback(pkgName);
369 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
370 }
371
372 /**
373 * @tc.name: UnRegisterCredentialCallback_001
374 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
375 * @tc.type: FUNC
376 */
377 HWTEST_F(DeviceManagerServiceImplTest, UnRegisterCredentialCallback_001, testing::ext::TestSize.Level0)
378 {
379 const std::string pkgName = "";
380 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
381 int32_t ret = deviceManagerServiceImpl->UnRegisterCredentialCallback(pkgName);
382 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
383 }
384
385 /**
386 * @tc.name: UnRegisterCredentialCallback_002
387 * @tc.desc: return ERR_DM_POINT_NULL
388 * @tc.type: FUNC
389 */
390 HWTEST_F(DeviceManagerServiceImplTest, UnRegisterCredentialCallback_002, testing::ext::TestSize.Level0)
391 {
392 const std::string pkgName = "pkgNameTest";
393 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
394 deviceManagerServiceImpl->credentialMgr_ = nullptr;
395 int32_t ret = deviceManagerServiceImpl->UnRegisterCredentialCallback(pkgName);
396 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
397 }
398
399 /**
400 * @tc.name: GetFaParam_001
401 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
402 * @tc.type: FUNC
403 */
404 HWTEST_F(DeviceManagerServiceImplTest, GetFaParam_001, testing::ext::TestSize.Level0)
405 {
406 std::string pkgName = "";
407 DmAuthParam authParam;
408 DmDeviceInfo info;
409 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
410 deviceManagerServiceImpl->softbusConnector_ = std::make_shared<SoftbusConnector>();
411 deviceManagerServiceImpl->HandleDeviceOnline(info);
412 int32_t ret = deviceManagerServiceImpl->GetFaParam(pkgName, authParam);
413 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
414 }
415
416 /**
417 * @tc.name: GetFaParam_002
418 * @tc.desc: return DM_OK
419 * @tc.type: FUNC
420 */
421 HWTEST_F(DeviceManagerServiceImplTest, GetFaParam_002, testing::ext::TestSize.Level0)
422 {
423 std::string pkgName = "com.ohos.test";
424 DmAuthParam authParam;
425 DmDeviceInfo info;
426 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
427 deviceManagerServiceImpl->softbusConnector_ = softbusConnector;
428 deviceManagerServiceImpl->authMgr_ =
429 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
430 deviceManagerServiceImpl->HandleDeviceOffline(info);
431 int32_t ret = deviceManagerServiceImpl->GetFaParam(pkgName, authParam);
432 EXPECT_EQ(ret, DM_OK);
433 }
434
435 /**
436 * @tc.name: SetUserOperation_001
437 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
438 * @tc.type: FUNC
439 */
440 HWTEST_F(DeviceManagerServiceImplTest, SetUserOperation_001, testing::ext::TestSize.Level0)
441 {
442 std::string pkgName = "";
443 int32_t action = 1;
444 const std::string params = "";
445 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
446 int32_t ret = deviceManagerServiceImpl->SetUserOperation(pkgName, action, params);
447 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
448 }
449
450 /**
451 * @tc.name: SetUserOperation_002
452 * @tc.desc: return DM_OK
453 * @tc.type: FUNC
454 */
455 HWTEST_F(DeviceManagerServiceImplTest, SetUserOperation_002, testing::ext::TestSize.Level0)
456 {
457 std::string pkgName = "com.ohos.test";
458 int32_t action = 1;
459 const std::string params = "paramsTest";
460 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
461 deviceManagerServiceImpl->authMgr_ =
462 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
463 int32_t ret = deviceManagerServiceImpl->SetUserOperation(pkgName, action, params);
464 EXPECT_EQ(ret, DM_OK);
465 }
466
467 /**
468 * @tc.name: UnRegisterDevStateCallback_001
469 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
470 * @tc.type: FUNC
471 */
472 HWTEST_F(DeviceManagerServiceImplTest, UnRegisterDevStateCallback_001, testing::ext::TestSize.Level0)
473 {
474 const std::string pkgName;
475 const std::string extra;
476 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
477 int32_t ret = deviceManagerServiceImpl->UnRegisterDevStateCallback(pkgName, extra);
478 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
479 }
480
481 /**
482 * @tc.name: UnRegisterDevStateCallback_002
483 * @tc.desc: return DM_OK
484 * @tc.type: FUNC
485 */
486 HWTEST_F(DeviceManagerServiceImplTest, UnRegisterDevStateCallback_002, testing::ext::TestSize.Level0)
487 {
488 const std::string pkgName = "com.ohos.test";
489 const std::string extra = "extraTest";
490 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
491 deviceManagerServiceImpl->deviceStateMgr_ =
492 std::make_shared<DmDeviceStateManager>(softbusConnector, listener, hiChainConnector_);
493 int32_t ret = deviceManagerServiceImpl->UnRegisterDevStateCallback(pkgName, extra);
494 EXPECT_EQ(ret, DM_OK);
495 }
496 } // namespace
497 } // namespace DistributedHardware
498 } // namespace OHOS
499