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_dm_auth_manager.h"
17
18 #include "nlohmann/json.hpp"
19
20 #include "dm_log.h"
21 #include "dm_constants.h"
22 #include "dm_auth_manager.h"
23 #include "auth_message_processor.h"
24 #include "device_manager_service_listener.h"
25
26 namespace OHOS {
27 namespace DistributedHardware {
SetUp()28 void DmAuthManagerTest::SetUp()
29 {
30 }
TearDown()31 void DmAuthManagerTest::TearDown()
32 {
33 }
SetUpTestCase()34 void DmAuthManagerTest::SetUpTestCase()
35 {
36 }
TearDownTestCase()37 void DmAuthManagerTest::TearDownTestCase()
38 {
39 }
40
41 namespace {
42 std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
43 std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
44 std::shared_ptr<HiChainConnector> hiChainConnector_ = std::make_shared<HiChainConnector>();
45 const int32_t MIN_PIN_CODE = 100000;
46 const int32_t MAX_PIN_CODE = 999999;
47
48 /**
49 * @tc.name: DmAuthManager::UnAuthenticateDevice_001
50 * @tc.desc: Call unauthenticateddevice to check whether the return value is DM_ FAILED
51 * @tc.type: FUNC
52 * @tc.require: AR000GHSJK
53 */
54 HWTEST_F(DmAuthManagerTest, UnAuthenticateDevice_001, testing::ext::TestSize.Level0)
55 {
56 std::shared_ptr<DmAuthManager> authManager =
57 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
58 std::shared_ptr<SoftbusSession> sessionSession = std::shared_ptr<SoftbusSession>();
59 std::shared_ptr<DmAuthRequestContext> authRequestContext = std::make_shared<DmAuthRequestContext>();
60 std::string pkgName = "";
61 std::string deviceId = "222";
62 int32_t ret = authManager->UnAuthenticateDevice(pkgName, deviceId);
63 ASSERT_EQ(ret, ERR_DM_FAILED);
64 }
65
66 /**
67 * @tc.name: DmAuthManager::HandleAuthenticateTimeout_001
68 * @tc.desc: authResponseContext_= nullptr; Call handleauthenticatemeout to check whether return value is ERR_DM_FAILED
69 * @tc.type: FUNC
70 * @tc.require: AR000GHSJK
71 */
72 HWTEST_F(DmAuthManagerTest, HandleAuthenticateTimeout_001, testing::ext::TestSize.Level0)
73 {
74 std::string name = "test";
75 std::shared_ptr<DmAuthManager> authManager =
76 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
77 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNetworkState>();
78 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
79 authManager->authRequestState_ = std::make_shared<AuthRequestNetworkState>();
80 authManager->authResponseContext_ = nullptr;
81 authManager->SetAuthRequestState(authRequestState);
82 authManager->HandleAuthenticateTimeout(name);
83 ASSERT_TRUE(authManager->authResponseContext_ != nullptr);
84 }
85
86 /**
87 * @tc.name: DmAuthManager::HandleAuthenticateTimeout_002
88 * @tc.desc: authResponseContext_= nullptr; Call handleauthenticatemeout to check whether the return value is DM_OK
89 * @tc.type: FUNC
90 * @tc.require: AR000GHSJK
91 */
92 HWTEST_F(DmAuthManagerTest, HandleAuthenticateTimeout_002, testing::ext::TestSize.Level0)
93 {
94 std::string name = "test";
95 std::shared_ptr<DmAuthManager> authManager =
96 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
97 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
98 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
99 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
100 authManager->authRequestState_ = std::make_shared<AuthRequestFinishState>();
101 authManager->SetAuthRequestState(authRequestState);
102 authManager->HandleAuthenticateTimeout(name);
103 ASSERT_TRUE(authManager->authRequestState_ != nullptr);
104 }
105
106 /**
107 * @tc.name: DmAuthManager::EstablishAuthChannel_001
108 * @tc.desc: Call establishauthchannel to check whether the return value is DM_ FAILED
109 * @tc.type: FUNC
110 * @tc.require: AR000GHSJK
111 */
112 HWTEST_F(DmAuthManagerTest, EstablishAuthChannel_001, testing::ext::TestSize.Level0)
113 {
114 std::shared_ptr<DmAuthManager> authManager =
115 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
116 std::shared_ptr<SoftbusSession> sessionSession = std::shared_ptr<SoftbusSession>();
117 std::shared_ptr<DmAuthResponseContext> authRequestContext = std::make_shared<DmAuthResponseContext>();
118 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
119 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
120 authManager->authRequestState_ = std::make_shared<AuthRequestFinishState>();
121 std::string deviceId1;
122 int32_t ret = authManager->EstablishAuthChannel(deviceId1);
123 ASSERT_EQ(ret, DM_OK);
124 }
125
126 /**
127 * @tc.name: DmAuthManager::StartAuthProcess_001
128 * @tc.desc: Whether the return value of calling startauthprocess is ERR_DM_FAILED
129 * @tc.type: FUNC
130 * @tc.require: AR000GHSJK
131 */
132 HWTEST_F(DmAuthManagerTest, StartAuthProcess_001, testing::ext::TestSize.Level0)
133 {
134 std::shared_ptr<DmAuthManager> authManager =
135 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
136 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseConfirmState>();
137 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
138 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
139 authManager->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
140 authManager->SetAuthResponseState(authResponseState);
141 int32_t action = 0;
142 authManager->StartAuthProcess(action);
143 bool ret = authManager->authRequestContext_->deviceName.empty();
144 ASSERT_EQ(ret, true);
145 }
146
147 /**
148 * @tc.name: DmAuthManager::StartAuthProcess_002
149 * @tc.desc: Whether the return value of calling startauthprocess is DM_ OK
150 * @tc.type: FUNC
151 * @tc.require: AR000GHSJK
152 */
153 HWTEST_F(DmAuthManagerTest, StartAuthProcess_002, testing::ext::TestSize.Level0)
154 {
155 std::shared_ptr<DmAuthManager> authManager =
156 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
157 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
158 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
159 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
160 authManager->authResponseState_ = std::make_shared<AuthResponseInitState>();
161 authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
162 authManager->SetAuthResponseState(authResponseState);
163 authManager->authResponseContext_->sessionId = 111;
164 authManager->softbusConnector_->GetSoftbusSession()->RegisterSessionCallback(authManager);
165 int32_t action = 1;
166 int32_t ret = authManager->StartAuthProcess(action);
167 ASSERT_EQ(ret, DM_OK);
168 }
169
170 /**
171 * @tc.name: DmAuthManager::CreateGroup_001
172 * @tc.desc: Whether the return value of calling creategroup is DM_ OK
173 * @tc.type: FUNC
174 * @tc.require: AR000GHSJK
175 */
176 HWTEST_F(DmAuthManagerTest, CreateGroup_001, testing::ext::TestSize.Level0)
177 {
178 std::shared_ptr<DmAuthManager> authManager =
179 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
180 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseConfirmState>();
181 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
182 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
183 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
184 authManager->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
185 authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
186 authManager->SetAuthResponseState(authResponseState);
187 authManager->authResponseContext_->requestId = 111;
188 authManager->authResponseContext_->groupName = "111";
189 int32_t ret = authManager->CreateGroup();
190 ASSERT_EQ(ret, DM_OK);
191 }
192
193 /**
194 * @tc.name: DmAuthManager::CreateGroup_002
195 * @tc.desc: Whether the return value of calling creategroup is ERR_DM_FAILED
196 * @tc.type: FUNC
197 * @tc.require: AR000GHSJK
198 */
199 HWTEST_F(DmAuthManagerTest, CreateGroup_002, testing::ext::TestSize.Level0)
200 {
201 std::shared_ptr<DmAuthManager> authManager =
202 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
203 authManager->authResponseContext_ = nullptr;
204 int32_t ret = authManager->CreateGroup();
205 ASSERT_EQ(ret, ERR_DM_FAILED);
206 }
207
208 /**
209 * @tc.name: DmAuthManager::AddMember_001
210 * @tc.desc: Whether the return value of calling addmember is DM_ OK
211 * @tc.type: FUNC
212 * @tc.require: AR000GHSJK
213 */
214 HWTEST_F(DmAuthManagerTest, AddMember_001, testing::ext::TestSize.Level0)
215 {
216 std::shared_ptr<DmAuthManager> authManager =
217 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
218 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
219 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
220 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
221 authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
222 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
223 nlohmann::json jsonObject;
224 authManager->authResponseContext_->groupId = "111";
225 authManager->authResponseContext_->groupName = "222";
226 authManager->authResponseContext_->code = 123;
227 authManager->authResponseContext_->requestId = 234;
228 authManager->authResponseContext_->deviceId = "234";
229 int32_t pinCode = 444444;
230 authManager->timer_ = std::make_shared<DmTimer>();
231 authManager->hiChainConnector_->RegisterHiChainCallback(authManager);
232 authManager->SetAuthResponseState(authResponseState);
233 int32_t ret = authManager->AddMember(pinCode);
234 ASSERT_NE(ret, -1);
235 }
236
237 /**
238 * @tc.name: DmAuthManager::JoinNetwork_001
239 * @tc.desc: Whether the return value of calling joinnetwork is DM_OK
240 * @tc.type: FUNC
241 * @tc.require: AR000GHSJK
242 */
243 HWTEST_F(DmAuthManagerTest, JoinNetwork_001, testing::ext::TestSize.Level0)
244 {
245 std::shared_ptr<DmAuthManager> authManager =
246 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
247 std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
248 authManager->timer_ = std::make_shared<DmTimer>();
249 authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
250 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
251 authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
252 authManager->authRequestState_ = std::make_shared<AuthRequestFinishState>();
253 const int32_t sessionId = 65;
254 const std::string message = "messageTest";
255 int64_t requestId = 444;
256 const std::string groupId = "{}";
257 int32_t status = 1;
258 authManager->OnGroupCreated(requestId, groupId);
259 authManager->OnMemberJoin(requestId, status);
260 authManager->OnDataReceived(sessionId, message);
261 authManager->SetAuthRequestState(authRequestState);
262 int32_t ret = authManager->JoinNetwork();
263 ASSERT_EQ(ret, DM_OK);
264 }
265
266 /**
267 * @tc.name: DmAuthManager::JoinNetwork_002
268 * @tc.desc: Whether the return value of calling joinnetwork is ERR_DM_FAILED
269 * @tc.type: FUNC
270 * @tc.require: AR000GHSJK
271 */
272 HWTEST_F(DmAuthManagerTest, JoinNetwork_002, testing::ext::TestSize.Level0)
273 {
274 std::shared_ptr<DmAuthManager> authManager =
275 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
276 authManager->authResponseContext_ = nullptr;
277 int32_t userId = 1;
278 bool isShow = false;
279 authManager->UserSwitchEventCallback(userId);
280 authManager->AuthenticateFinish();
281 authManager->CancelDisplay();
282 authManager->UpdateInputDialogDisplay(isShow);
283 int32_t ret = authManager->JoinNetwork();
284 ASSERT_EQ(ret, ERR_DM_FAILED);
285 }
286
287 /**
288 * @tc.name: DmAuthManager::SetAuthResponseState_001
289 * @tc.desc: Is the authresponsestate assignment successful
290 * @tc.type: FUNC
291 * @tc.require: AR000GHSJK
292 */
293 HWTEST_F(DmAuthManagerTest, SetAuthResponseState_001, testing::ext::TestSize.Level0)
294 {
295 std::shared_ptr<DmAuthManager> authManager =
296 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
297 std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseFinishState>();
298 authManager->authResponseState_ = std::make_shared<AuthResponseFinishState>();
299 authManager->SetAuthResponseState(authResponseState);
300 int32_t ret = authManager->SetAuthResponseState(authResponseState);
301 ASSERT_EQ(ret, DM_OK);
302 }
303
304 /**
305 * @tc.name: DmAuthManager::GetPinCode_001
306 * @tc.desc: Return authresponsecontext - > code
307 * @tc.type: FUNC
308 * @tc.require: AR000GHSJK
309 */
310 HWTEST_F(DmAuthManagerTest, GetPinCode_001, testing::ext::TestSize.Level0)
311 {
312 std::shared_ptr<DmAuthManager> authManager =
313 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
314 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
315 authManager->authResponseContext_->code = 123456;
316 int32_t ret = authManager->GetPinCode();
317 ASSERT_EQ(ret, 123456);
318 }
319
320 /**
321 * @tc.name: DmAuthManager::SetPageId_001
322 * @tc.desc: Return DM_OK
323 * @tc.type: FUNC
324 * @tc.require: AR000GHSJK
325 */
326 HWTEST_F(DmAuthManagerTest, SetPageId_001, testing::ext::TestSize.Level0)
327 {
328 std::shared_ptr<DmAuthManager> authManager =
329 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
330 int32_t pageId = 123;
331 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
332 int32_t ret = authManager->SetPageId(pageId);
333 ASSERT_EQ(ret, DM_OK);
334 }
335
336 /**
337 * @tc.name: DmAuthManager::SetPageId_002
338 * @tc.desc: Return ERR_DM_AUTH_NOT_START
339 * @tc.type: FUNC
340 * @tc.require: AR000GHSJK
341 */
342 HWTEST_F(DmAuthManagerTest, SetPageId_002, testing::ext::TestSize.Level0)
343 {
344 std::shared_ptr<DmAuthManager> authManager =
345 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
346 int32_t pageId = 123;
347 authManager->authResponseContext_ = nullptr;
348 authManager->authMessageProcessor_ = nullptr;
349 const int32_t sessionId = 65;
350 const std::string message = "messageTest";
351 int64_t requestId = 555;
352 int32_t status = 2;
353 authManager->OnMemberJoin(requestId, status);
354 authManager->OnDataReceived(sessionId, message);
355 int32_t ret = authManager->SetPageId(pageId);
356 ASSERT_EQ(ret, ERR_DM_AUTH_NOT_START);
357 }
358
359 /**
360 * @tc.name: DmAuthManager::SetReasonAndFinish_001
361 * @tc.desc: Return ERR_DM_AUTH_NOT_START
362 * @tc.type: FUNC
363 * @tc.require: AR000GHSJK
364 */
365 HWTEST_F(DmAuthManagerTest, SetReasonAndFinish_001, testing::ext::TestSize.Level0)
366 {
367 std::shared_ptr<DmAuthManager> authManager =
368 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
369 const int32_t sessionId = 78;
370 int32_t reason = 123;
371 int32_t state = 456;
372 authManager->OnSessionClosed(sessionId);
373 authManager->authResponseContext_ = nullptr;
374 int64_t requestId = 333;
375 const std::string groupId = "{}";
376 authManager->OnGroupCreated(requestId, groupId);
377 int32_t ret = authManager->SetReasonAndFinish(reason, state);
378 ASSERT_EQ(ret, ERR_DM_AUTH_NOT_START);
379 }
380
381 /**
382 * @tc.name: DmAuthManager::SetReasonAndFinish_002
383 * @tc.desc: Return DM_OK
384 * @tc.type: FUNC
385 * @tc.require: AR000GHSJK
386 */
387 HWTEST_F(DmAuthManagerTest, SetReasonAndFinish_002, testing::ext::TestSize.Level0)
388 {
389 std::shared_ptr<DmAuthManager> authManager =
390 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
391 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
392 authManager->authRequestState_ = std::make_shared<AuthRequestFinishState>();
393 int32_t reason = 1234;
394 int32_t state = 5678;
395 int64_t requestId = 22;
396 const std::string groupId = "{}";
397 authManager->OnGroupCreated(requestId, groupId);
398 int32_t ret = authManager->SetReasonAndFinish(reason, state);
399 ASSERT_EQ(ret, DM_OK);
400 }
401
402 /**
403 * @tc.name: DmAuthManager::SetReasonAndFinish_003
404 * @tc.desc: Return DM_OK
405 * @tc.type: FUNC
406 * @tc.require: AR000GHSJK
407 */
408 HWTEST_F(DmAuthManagerTest, SetReasonAndFinish_003, testing::ext::TestSize.Level0)
409 {
410 std::shared_ptr<DmAuthManager> authManager =
411 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
412 authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
413 authManager->authRequestState_ = nullptr;
414 authManager->authResponseState_ = std::make_shared<AuthResponseFinishState>();
415 int32_t reason = 12;
416 int32_t state = 36;
417 int32_t ret = authManager->SetReasonAndFinish(reason, state);
418 ASSERT_EQ(ret, DM_OK);
419 }
420
421 /**
422 * @tc.name: DmAuthManager::IsIdenticalAccount_001
423 * @tc.desc: Return false
424 * @tc.type: FUNC
425 * @tc.require: AR000GHSJK
426 */
427 HWTEST_F(DmAuthManagerTest, IsIdenticalAccount_001, testing::ext::TestSize.Level0)
428 {
429 std::shared_ptr<DmAuthManager> authManager =
430 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
431 bool ret = authManager->IsIdenticalAccount();
432 ASSERT_EQ(ret, false);
433 }
434
435 /**
436 * @tc.name: DmAuthManager::GeneratePincode_001
437 * @tc.desc: Return OK
438 * @tc.type: FUNC
439 * @tc.require: AR000GHSJK
440 */
441 HWTEST_F(DmAuthManagerTest, GeneratePincode_001, testing::ext::TestSize.Level0)
442 {
443 std::shared_ptr<DmAuthManager> authManager =
444 std::make_shared<DmAuthManager>(softbusConnector, listener, hiChainConnector_);
445 int32_t openedSessionId = 66;
446 int32_t sessionSide = 0;
447 int32_t result = 3;
448 const int32_t closedSessionId = 11;
449 authManager->OnSessionOpened(openedSessionId, sessionSide, result);
450 authManager->OnSessionClosed(closedSessionId);
451 int32_t ret = authManager->GeneratePincode();
452 ASSERT_LE(ret, MAX_PIN_CODE);
453 ASSERT_GE(ret, MIN_PIN_CODE);
454 }
455 } // namespace
456 } // namespace DistributedHardware
457 } // namespace OHOS
458