From 766152da2837708945166f5de8862fb21aa7f8e5 Mon Sep 17 00:00:00 2001 From: BrainL Date: Fri, 13 Jun 2025 14:45:38 +0800 Subject: [PATCH 1/2] add UT Signed-off-by: BrainL --- ...Test_device_manager_service_impl_first.cpp | 954 ++++++++++++++++++ ...UTTest_device_manager_service_impl_first.h | 5 +- .../mock/device_manager_service_impl_mock.cpp | 26 + .../mock/device_manager_service_impl_mock.h | 14 + .../mock/deviceprofile_connector_mock.cpp | 62 ++ .../mock/deviceprofile_connector_mock.h | 41 + .../mock/multiple_user_connector_mock.cpp | 10 + .../mock/multiple_user_connector_mock.h | 4 + test/unittest/mock/softbus_connector_mock.cpp | 5 + test/unittest/mock/softbus_connector_mock.h | 2 + 10 files changed, 1122 insertions(+), 1 deletion(-) diff --git a/test/unittest/UTTest_device_manager_service_impl_first.cpp b/test/unittest/UTTest_device_manager_service_impl_first.cpp index 3badcf299..11c285da9 100644 --- a/test/unittest/UTTest_device_manager_service_impl_first.cpp +++ b/test/unittest/UTTest_device_manager_service_impl_first.cpp @@ -44,6 +44,7 @@ void DeviceManagerServiceImplFirstTest::SetUpTestCase() DmDmDeviceStateManager::dmDeviceStateManager = dmDeviceStateManagerMock_; DmDeviceManagerServiceImpl::dmDeviceManagerServiceImpl = deviceManagerServiceImplMock_; DmHiChainConnector::dmHiChainConnector = hiChainConnectorMock_; + DmHiChainAuthConnector::dmHiChainAuthConnector = hiChainAuthConnectorMock_; } void DeviceManagerServiceImplFirstTest::TearDownTestCase() @@ -60,6 +61,8 @@ void DeviceManagerServiceImplFirstTest::TearDownTestCase() deviceManagerServiceImplMock_ = nullptr; DmHiChainConnector::dmHiChainConnector = nullptr; hiChainConnectorMock_ = nullptr; + DmHiChainAuthConnector::dmHiChainAuthConnector = nullptr; + hiChainAuthConnectorMock_ = nullptr; } namespace { @@ -784,6 +787,957 @@ HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAclByTokenId_002, testing::ext EXPECT_TRUE(delACLInfoVec.empty()); EXPECT_TRUE(userIdVec.empty()); } + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAclByTokenId_003, testing::ext::TestSize.Level1) +{ + int32_t accessTokenId = 1234; + std::vector profiles; + std::map delProfileMap; + std::vector> delACLInfoVec; + std::vector userIdVec; + + deviceManagerServiceImpl_->DeleteAclByTokenId(accessTokenId, profiles, delProfileMap, delACLInfoVec, userIdVec); + + EXPECT_TRUE(profiles.empty()); + EXPECT_TRUE(delProfileMap.empty()); + EXPECT_TRUE(delACLInfoVec.empty()); + EXPECT_TRUE(userIdVec.empty()); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAclByTokenId_004, testing::ext::TestSize.Level1) +{ + int32_t accessTokenId = 1234; + std::vector profiles; + DistributedDeviceProfile::AccessControlProfile profile; + profile.GetAccesser().SetAccesserTokenId(5678); + profile.GetAccessee().SetAccesseeTokenId(8765); + profiles.push_back(profile); + + std::map delProfileMap; + std::vector> delACLInfoVec; + std::vector userIdVec; + + deviceManagerServiceImpl_->DeleteAclByTokenId(accessTokenId, profiles, delProfileMap, delACLInfoVec, userIdVec); + + EXPECT_TRUE(delProfileMap.empty()); + EXPECT_TRUE(delACLInfoVec.empty()); + EXPECT_TRUE(userIdVec.empty()); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAclByTokenId_005, testing::ext::TestSize.Level1) +{ + int32_t accessTokenId = 1234; + std::vector profiles; + std::map delProfileMap; + std::vector> delACLInfoVec; + std::vector userIdVec; + + deviceManagerServiceImpl_->DeleteAclByTokenId(accessTokenId, profiles, delProfileMap, delACLInfoVec, userIdVec); + + EXPECT_TRUE(profiles.empty()); + EXPECT_TRUE(delProfileMap.empty()); + EXPECT_TRUE(delACLInfoVec.empty()); + EXPECT_TRUE(userIdVec.empty()); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAclByTokenId_006, testing::ext::TestSize.Level1) +{ + int32_t accessTokenId = 1234; + std::vector profiles; + DistributedDeviceProfile::AccessControlProfile profile; + profile.GetAccesser().SetAccesserTokenId(5678); + profile.GetAccessee().SetAccesseeTokenId(8765); + profiles.push_back(profile); + + std::map delProfileMap; + std::vector> delACLInfoVec; + std::vector userIdVec; + + deviceManagerServiceImpl_->DeleteAclByTokenId(accessTokenId, profiles, delProfileMap, delACLInfoVec, userIdVec); + + EXPECT_TRUE(delProfileMap.empty()); + EXPECT_TRUE(delACLInfoVec.empty()); + EXPECT_TRUE(userIdVec.empty()); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, CheckLnnAcl_001, testing::ext::TestSize.Level1) +{ + DistributedDeviceProfile::AccessControlProfile p1, p2; + p1.GetAccesser().SetAccesserDeviceId("devA"); + p1.GetAccesser().SetAccesserUserId(1); + p1.GetAccessee().SetAccesseeDeviceId("devB"); + p1.GetAccessee().SetAccesseeUserId(2); + + p2.GetAccesser().SetAccesserDeviceId("devA"); + p2.GetAccesser().SetAccesserUserId(1); + p2.GetAccessee().SetAccesseeDeviceId("devB"); + p2.GetAccessee().SetAccesseeUserId(2); + + bool ret = deviceManagerServiceImpl_->CheckLnnAcl(p1, p2); + EXPECT_TRUE(ret); + + DistributedDeviceProfile::AccessControlProfile p3, p4; + p3.GetAccesser().SetAccesserDeviceId("devA"); + p3.GetAccesser().SetAccesserUserId(1); + p3.GetAccessee().SetAccesseeDeviceId("devB"); + p3.GetAccessee().SetAccesseeUserId(2); + + p4.GetAccesser().SetAccesserDeviceId("devB"); + p4.GetAccesser().SetAccesserUserId(2); + p4.GetAccessee().SetAccesseeDeviceId("devA"); + p4.GetAccessee().SetAccesseeUserId(1); + + EXPECT_TRUE(deviceManagerServiceImpl_->CheckLnnAcl(p3, p4)); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, SaveOnlineDeviceInfo_001, testing::ext::TestSize.Level1) +{ + deviceManagerServiceImpl_->deviceStateMgr_ = nullptr; + std::vector deviceList; + int32_t ret = deviceManagerServiceImpl_->SaveOnlineDeviceInfo(deviceList); + EXPECT_EQ(ret, ERR_DM_POINT_NULL); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, SaveOnlineDeviceInfo_002, testing::ext::TestSize.Level1) +{ + std::vector deviceList; + int32_t ret = deviceManagerServiceImpl_->SaveOnlineDeviceInfo(deviceList); + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, SaveOnlineDeviceInfo_003, testing::ext::TestSize.Level1) +{ + std::vector deviceList(2); + int32_t ret = deviceManagerServiceImpl_->SaveOnlineDeviceInfo(deviceList); + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAlwaysAllowTimeOut_001, testing::ext::TestSize.Level1) +{ + size_t before = DeviceProfileConnector::GetInstance().GetAllAccessControlProfile().size(); + deviceManagerServiceImpl_->DeleteAlwaysAllowTimeOut(); + size_t after = DeviceProfileConnector::GetInstance().GetAllAccessControlProfile().size(); + EXPECT_EQ(before, after); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, HandleCredentialDeleted_005, testing::ext::TestSize.Level1) +{ + const char *credId = "123456"; + const char *credInfo = "invalid_json"; + std::string localUdid = "localUdid"; + std::string remoteUdid; + bool isShareType = false; + std::vector profiles; + EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile()) + .WillOnce(Return(profiles)); + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_)).Times(0); + + deviceManagerServiceImpl_->HandleCredentialDeleted(credId, credInfo, localUdid, remoteUdid); + EXPECT_FALSE(isShareType); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, HandleCredentialDeleted_006, testing::ext::TestSize.Level1) +{ + const char *credId = "123456"; + const char *credInfo = R"({"deviceId": "remoteUdid", "osAccountId": 1})"; + std::string localUdid = "localUdid"; + std::string remoteUdid; + bool isShareType = false; + + std::vector profiles; + DistributedDeviceProfile::AccessControlProfile profile; + profile.SetBindType(DM_POINT_TO_POINT); + profiles.push_back(profile); + + EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile()) + .Times(AtLeast(1)) + .WillOnce(Return(profiles)); + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_)).Times(0); + + deviceManagerServiceImpl_->HandleCredentialDeleted(credId, credInfo, localUdid, remoteUdid); + EXPECT_FALSE(isShareType); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, HandleShareUnbindBroadCast_006, testing::ext::TestSize.Level1) +{ + std::string credId = "12345"; + std::string localUdid = "localId"; + int32_t userId = 123456; + + std::vector profiles; + EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile()) + .WillOnce(Return(profiles)); + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_)).Times(0); + + deviceManagerServiceImpl_->HandleShareUnbindBroadCast(credId, userId, localUdid); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, HandleShareUnbindBroadCast_007, testing::ext::TestSize.Level1) +{ + std::string credId = "12345"; + std::string localUdid = "localId"; + int32_t userId = 123456; + + std::vector profiles; + AccessControlProfile profile; + profile.SetBindType(DM_IDENTICAL_ACCOUNT); + profiles.push_back(profile); + + EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile()) + .WillOnce(Return(profiles)); + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_)).Times(0); + + deviceManagerServiceImpl_->HandleShareUnbindBroadCast(credId, userId, localUdid); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, HandleShareUnbindBroadCast_008, testing::ext::TestSize.Level1) +{ + std::string credId = "12345"; + std::string localUdid = "localId"; + int32_t userId = 123456; + + std::vector profiles; + AccessControlProfile profile; + profile.SetBindType(DM_SHARE); + + Accesser accesser; + accesser.SetAccesserCredentialId(atoi(credId.c_str())); + accesser.SetAccesserUserId(userId); + profile.SetAccesser(accesser); + + Accessee accessee; + accessee.SetAccesseeDeviceId(localUdid); + accessee.SetAccesseeUserId(MultipleUserConnector::GetCurrentAccountUserID()); + profile.SetAccessee(accessee); + + profiles.push_back(profile); + + EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile()) + .WillOnce(Return(profiles)); + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_)).Times(1); + + deviceManagerServiceImpl_->HandleShareUnbindBroadCast(credId, userId, localUdid); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, HandleShareUnbindBroadCast_009, testing::ext::TestSize.Level1) +{ + std::string credId = "12345"; + std::string localUdid = "localUdid"; + int32_t userId = 123456; + + std::vector profiles; + AccessControlProfile profile; + profile.SetBindType(DM_SHARE); + + Accesser accesser; + accesser.SetAccesserDeviceId(localUdid); + profile.SetAccesser(accesser); + + Accessee accessee; + accessee.SetAccesseeCredentialId(atoi(credId.c_str())); + accessee.SetAccesseeUserId(userId); + profile.SetAccessee(accessee); + + profiles.push_back(profile); + + EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile()) + .WillOnce(Return(profiles)); + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_)).Times(1); + + deviceManagerServiceImpl_->HandleShareUnbindBroadCast(credId, userId, localUdid); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, HandleShareUnbindBroadCast_010, testing::ext::TestSize.Level1) +{ + std::string credId = "12345"; + std::string localUdid = "localUdid"; + int32_t userId = 123456; + + std::vector profiles; + AccessControlProfile profile; + profile.SetBindType(DM_SHARE); + + Accesser accesser; + accesser.SetAccesserCredentialId(9999); + accesser.SetAccesserDeviceId("peer123"); + accesser.SetAccesserUserId(1002); + profile.SetAccesser(accesser); + + Accessee accessee; + accessee.SetAccesseeDeviceId("peer456"); + accessee.SetAccesseeUserId(1003); + profile.SetAccessee(accessee); + + profiles.push_back(profile); + + EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile()) + .WillOnce(Return(profiles)); + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_)).Times(0); + + deviceManagerServiceImpl_->HandleShareUnbindBroadCast(credId, userId, localUdid); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, CheckDeviceInfoPermission_001, testing::ext::TestSize.Level1) +{ + std::string localUdid = "localUdid"; + std::string peerDeviceId = "peerDeviceId"; + + EXPECT_CALL(*deviceProfileConnectorMock_, CheckDeviceInfoPermission(localUdid, peerDeviceId)) + .WillOnce(Return(DM_OK)); + + int32_t ret = deviceManagerServiceImpl_->CheckDeviceInfoPermission(localUdid, peerDeviceId); + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, CheckDeviceInfoPermission_002, testing::ext::TestSize.Level1) +{ + std::string localUdid = "localUdid"; + std::string peerDeviceId = "peerDeviceId"; + + EXPECT_CALL(*deviceProfileConnectorMock_, CheckDeviceInfoPermission(localUdid, peerDeviceId)) + .WillOnce(Return(ERR_DM_FAILED)); + + int32_t ret = deviceManagerServiceImpl_->CheckDeviceInfoPermission(localUdid, peerDeviceId); + EXPECT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAcl_001, testing::ext::TestSize.Level1) +{ + std::string pkgName = "pkg"; + std::string localUdid = "localUdid"; + std::string remoteUdid = "remoteUdid"; + int32_t bindLevel = USER; + std::string extra = ""; + DmOfflineParam offlineParam; + offlineParam.bindType = INVALIED_TYPE; + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlList(pkgName, localUdid, remoteUdid, bindLevel, extra)) + .WillOnce(Return(offlineParam)); + + int32_t ret = deviceManagerServiceImpl_->DeleteAcl(pkgName, localUdid, remoteUdid, bindLevel, extra); + EXPECT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAcl_002, testing::ext::TestSize.Level1) +{ + std::string pkgName = "pkg"; + std::string localUdid = "localUdid"; + std::string remoteUdid = "remoteUdid"; + int32_t bindLevel = APP; + std::string extra = ""; + + DmOfflineParam offlineParam; + offlineParam.bindType = APP; + offlineParam.leftAclNumber = 1; + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlList(pkgName, localUdid, remoteUdid, bindLevel, extra)) + .WillOnce(Return(offlineParam)); + EXPECT_CALL(*softbusConnectorMock_, SetProcessInfoVec(_)).Times(1); + EXPECT_CALL(*softbusConnectorMock_, HandleDeviceOffline(remoteUdid)).Times(1); + + int32_t ret = deviceManagerServiceImpl_->DeleteAcl(pkgName, localUdid, remoteUdid, bindLevel, extra); + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAcl_003, testing::ext::TestSize.Level1) +{ + std::string pkgName = "pkg"; + std::string localUdid = "localUdid"; + std::string remoteUdid = "remoteUdid"; + int32_t bindLevel = APP; + std::string extra = ""; + + DmOfflineParam offlineParam; + offlineParam.bindType = APP; + offlineParam.leftAclNumber = 0; + offlineParam.peerUserId = 1001; + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlList(pkgName, localUdid, remoteUdid, bindLevel, extra)) + .WillOnce(Return(offlineParam)); + EXPECT_CALL(*softbusConnectorMock_, SetProcessInfoVec(_)).Times(1); + + int32_t ret = deviceManagerServiceImpl_->DeleteAcl(pkgName, localUdid, remoteUdid, bindLevel, extra); + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAcl_004, testing::ext::TestSize.Level1) +{ + std::string pkgName = "pkg"; + std::string localUdid = "localUdid"; + std::string remoteUdid = "remoteUdid"; + int32_t bindLevel = USER; + std::string extra = ""; + + DmOfflineParam offlineParam; + offlineParam.bindType = USER; + offlineParam.leftAclNumber = 1; + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlList(pkgName, localUdid, remoteUdid, bindLevel, extra)) + .WillOnce(Return(offlineParam)); + + int32_t ret = deviceManagerServiceImpl_->DeleteAcl(pkgName, localUdid, remoteUdid, bindLevel, extra); + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAcl_005, testing::ext::TestSize.Level1) +{ + std::string pkgName = "pkg"; + std::string localUdid = "localUdid"; + std::string remoteUdid = "remoteUdid"; + int32_t bindLevel = USER; + std::string extra = ""; + + DmOfflineParam offlineParam; + offlineParam.bindType = USER; + offlineParam.leftAclNumber = 0; + offlineParam.peerUserId = 1002; + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlList(pkgName, localUdid, remoteUdid, bindLevel, extra)) + .WillOnce(Return(offlineParam)); + int32_t ret = deviceManagerServiceImpl_->DeleteAcl(pkgName, localUdid, remoteUdid, bindLevel, extra); + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAcl_006, testing::ext::TestSize.Level1) +{ + std::string pkgName = "pkg"; + std::string localUdid = "localUdid"; + std::string remoteUdid = "remoteUdid"; + int32_t bindLevel = 999; + std::string extra = ""; + + DmOfflineParam offlineParam; + offlineParam.bindType = 999; + offlineParam.leftAclNumber = 0; + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlList(pkgName, localUdid, remoteUdid, bindLevel, extra)) + .WillOnce(Return(offlineParam)); + + int32_t ret = deviceManagerServiceImpl_->DeleteAcl(pkgName, localUdid, remoteUdid, bindLevel, extra); + EXPECT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteSkCredAndAcl_001, testing::ext::TestSize.Level1) +{ + std::vector acls; + int32_t ret = deviceManagerServiceImpl_->DeleteSkCredAndAcl(acls); + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteSkCredAndAcl_002, testing::ext::TestSize.Level1) +{ + std::vector acls = { {"udid", 1, 2, 3, "cred"} }; + deviceManagerServiceImpl_->hiChainAuthConnector_ = nullptr; + int32_t ret = deviceManagerServiceImpl_->DeleteSkCredAndAcl(acls); + EXPECT_EQ(ret, ERR_DM_POINT_NULL); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteSkCredAndAcl_003, testing::ext::TestSize.Level1) +{ + std::vector acls = { {"udid3", 12, 23, 34, "credid3"} }; + + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteSessionKey(12, 34)).WillOnce(Return(DM_OK)); + EXPECT_CALL(*hiChainAuthConnectorMock_, DeleteCredential(12, "credid3")).WillOnce(Return(ERR_DM_FAILED)); + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_)).Times(1); + + int32_t ret = deviceManagerServiceImpl_->DeleteSkCredAndAcl(acls); + EXPECT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAclForProcV2_004, testing::ext::TestSize.Level1) +{ + DmAclIdParam aclParam = {"udid", 1, 2, 3, "credid"}; + DmOfflineParam offlineParam; + offlineParam.needDelAclInfos.push_back(aclParam); + + EXPECT_CALL(*deviceProfileConnectorMock_, FilterNeedDeleteACL(_, _, _, _)) + .WillOnce(Return(offlineParam)); + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteSessionKey(1, 3)).WillOnce(Return(DM_OK)); + EXPECT_CALL(*hiChainAuthConnectorMock_, DeleteCredential(1, "credid")).WillOnce(Return(DM_OK)); + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_)).Times(1); + + int32_t ret = deviceManagerServiceImpl_->DeleteAclForProcV2("localUdid", 100, "remoteUdid", 1, "extra", 10); + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAclForProcV2_005, testing::ext::TestSize.Level1) +{ + DmAclIdParam lnnAclParam = {"lnnudid", 2, 3, 4, "lnncred"}; + DmOfflineParam offlineParam; + offlineParam.allLnnAclInfos.push_back(lnnAclParam); + + EXPECT_CALL(*deviceProfileConnectorMock_, FilterNeedDeleteACL(_, _, _, _)) + .WillOnce(Return(offlineParam)); + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteSessionKey(2, 4)).WillOnce(Return(DM_OK)); + EXPECT_CALL(*hiChainAuthConnectorMock_, DeleteCredential(2, "lnncred")).WillOnce(Return(DM_OK)); + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_)).Times(1); + + int32_t ret = deviceManagerServiceImpl_->DeleteAclForProcV2("localUdid", 100, "remoteUdid", 1, "extra", 10); + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAclForProcV2_006, testing::ext::TestSize.Level1) +{ + DmAclIdParam appAclParam = {"appudid", 3, 4, 5, "appcred"}; + DmOfflineParam offlineParam; + offlineParam.allLeftAppOrSvrAclInfos.push_back(appAclParam); + + EXPECT_CALL(*deviceProfileConnectorMock_, FilterNeedDeleteACL(_, _, _, _)) + .WillOnce(Return(offlineParam)); + EXPECT_CALL(*softbusConnectorMock_, SetProcessInfoVec(_)).Times(1); + EXPECT_CALL(*softbusConnectorMock_, HandleDeviceOffline("remoteUdid")).Times(1); + + int32_t ret = deviceManagerServiceImpl_->DeleteAclForProcV2("localUdid", 100, "remoteUdid", 1, "extra", 10); + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAclForProcV2_007, testing::ext::TestSize.Level1) +{ + DmOfflineParam offlineParam; + DmOfflineParam outputParam; + outputParam.leftAclNumber = 0; + outputParam.bindType = 1; + EXPECT_CALL(*deviceProfileConnectorMock_, FilterNeedDeleteACL(_, _, _, _)) + .WillOnce(Return(offlineParam)); + int32_t ret = deviceManagerServiceImpl_->DeleteAclForProcV2("localUdid", 100, "remoteUdid", 1, "extra", 10); + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAclV2_001, testing::ext::TestSize.Level1) +{ + std::string pkgName = "pkg"; + std::string localUdid = "localUdid"; + std::string remoteUdid = "remoteUdid"; + int32_t bindLevel = 3; + std::string extra = "extra"; + DmOfflineParam outputParam; + outputParam.leftAclNumber = 0; + outputParam.bindType = 1; + + EXPECT_CALL(*deviceManagerServiceImplMock_, IsAuthNewVersion(bindLevel, localUdid, remoteUdid, _, _)) + .WillOnce(Return(true)); + EXPECT_CALL(*deviceManagerServiceImplMock_, DeleteAclForProcV2(localUdid, _, remoteUdid, bindLevel, extra, _)) + .WillOnce(Return(DM_OK)); + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlList(_, _, _, _, _)) + .WillOnce(Return(outputParam)); + + int32_t ret = deviceManagerServiceImpl_->DeleteAclV2(pkgName, localUdid, remoteUdid, bindLevel, extra); + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, HandleCommonEventBroadCast_001, testing::ext::TestSize.Level1) +{ + std::vector foregroundUserIds = {1, 2}; + std::vector backgroundUserIds = {3, 4}; + std::string remoteUdid = "remoteUdid"; + + EXPECT_CALL(*multipleUserConnectorMock_, GetForegroundUserIds(_)) + .WillOnce(Return(ERR_DM_FAILED)); + + deviceManagerServiceImpl_->HandleCommonEventBroadCast(foregroundUserIds, backgroundUserIds, remoteUdid); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, HandleCommonEventBroadCast_002, testing::ext::TestSize.Level1) +{ + std::vector foregroundUserIds = {1, 2}; + std::vector backgroundUserIds = {3, 4}; + std::string remoteUdid = "remoteUdid"; + std::vector localUserIds = {10, 20}; + + EXPECT_CALL(*multipleUserConnectorMock_, GetForegroundUserIds(_)) + .WillOnce(DoAll(SetArgReferee<0>(localUserIds), Return(DM_OK))); + + DmOfflineParam offlineParam; + EXPECT_CALL(*deviceProfileConnectorMock_, UpdateACL(_, _, _, _, _, _)) + .WillOnce(DoAll(SetArgReferee<5>(offlineParam), Return())); + + EXPECT_CALL(*deviceProfileConnectorMock_, HandleSyncBackgroundUserIdEvent(_, _, _, _)).Times(1); + EXPECT_CALL(*deviceProfileConnectorMock_, HandleSyncForegroundUserIdEvent(_, _, _, _)).Times(1); + + deviceManagerServiceImpl_->HandleCommonEventBroadCast(foregroundUserIds, backgroundUserIds, remoteUdid); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, HandleCommonEventBroadCast_003, testing::ext::TestSize.Level1) +{ + std::vector foregroundUserIds = {1}; + std::vector backgroundUserIds = {2}; + std::string remoteUdid = "remoteUdid"; + std::vector localUserIds = {100}; + + EXPECT_CALL(*multipleUserConnectorMock_, GetForegroundUserIds(_)) + .WillOnce(DoAll(SetArgReferee<0>(localUserIds), Return(DM_OK))); + EXPECT_CALL(*multipleUserConnectorMock_, ClearLockedUser(localUserIds)).Times(1); + + DmOfflineParam offlineParam; + DmAclIdParam aclParam = {"udid", 1, 2, 3, "credid"}; + offlineParam.needDelAclInfos.push_back(aclParam); + EXPECT_CALL(*deviceProfileConnectorMock_, UpdateACL(_, _, _, _, _, _)) + .WillOnce(DoAll(SetArgReferee<5>(offlineParam), Return())); + + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteSessionKey(1, 3)).WillOnce(Return(DM_OK)); + EXPECT_CALL(*hiChainAuthConnectorMock_, DeleteCredential(1, "credid")).WillOnce(Return(DM_OK)); + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_)).Times(1); + + EXPECT_CALL(*deviceProfileConnectorMock_, HandleSyncBackgroundUserIdEvent(_, _, _, _)).Times(1); + EXPECT_CALL(*deviceProfileConnectorMock_, HandleSyncForegroundUserIdEvent(_, _, _, _)).Times(1); + + deviceManagerServiceImpl_->HandleCommonEventBroadCast(foregroundUserIds, backgroundUserIds, remoteUdid); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, GetBindCallerInfo_001, testing::ext::TestSize.Level1) +{ + DmBindCallerInfo info; + std::string pkgName = "com.test.pkg"; + + EXPECT_CALL(*multipleUserConnectorMock_, GetCallerUserId(_)) + .WillOnce([](int32_t &userId) { userId = 123; }); + EXPECT_CALL(*multipleUserConnectorMock_, GetCallingTokenId(_)) + .WillOnce([](uint32_t &tokenId) { tokenId = 456; }); + + EXPECT_CALL(*deviceManagerServiceImplMock_, GetBundleLable(pkgName)) + .WillOnce(Return("label")); + + deviceManagerServiceImpl_->GetBindCallerInfo(info, pkgName); + + EXPECT_EQ(info.userId, 123); + EXPECT_EQ(info.tokenId, 456); + EXPECT_EQ(info.hostPkgLabel, "com.test.pkg"); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, GetBundleLable_001, testing::ext::TestSize.Level1) +{ + std::string bundleName = "test.bundle"; + std::string label = deviceManagerServiceImpl_->GetBundleLable(bundleName); + EXPECT_EQ(label, bundleName); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, CheckSrcAccessControl_001, testing::ext::TestSize.Level1) +{ + DmAccessCaller caller; + std::string srcUdid = "srcUdid"; + DmAccessCallee callee; + std::string sinkUdid = "sinkUdid"; + + EXPECT_CALL(*deviceProfileConnectorMock_, CheckSrcAccessControl(_, _, _, _)) + .WillOnce(Return(false)); + + bool ret = deviceManagerServiceImpl_->CheckSrcAccessControl(caller, srcUdid, callee, sinkUdid); + EXPECT_FALSE(ret); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, CheckSinkAccessControl_001, testing::ext::TestSize.Level1) +{ + DmAccessCaller caller; + std::string srcUdid = "srcUdid"; + DmAccessCallee callee; + std::string sinkUdid = "sinkUdid"; + + EXPECT_CALL(*deviceProfileConnectorMock_, CheckSinkAccessControl(_, _, _, _)) + .WillOnce(Return(false)); + + bool ret = deviceManagerServiceImpl_->CheckSinkAccessControl(caller, srcUdid, callee, sinkUdid); + EXPECT_FALSE(ret); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, CheckSrcIsSameAccount_001, testing::ext::TestSize.Level1) +{ + DmAccessCaller caller; + std::string srcUdid = "srcUdid"; + DmAccessCallee callee; + std::string sinkUdid = "sinkUdid"; + + EXPECT_CALL(*deviceProfileConnectorMock_, CheckSrcIsSameAccount(_, _, _, _)) + .WillOnce(Return(false)); + + bool ret = deviceManagerServiceImpl_->CheckSrcIsSameAccount(caller, srcUdid, callee, sinkUdid); + EXPECT_FALSE(ret); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, CheckSinkIsSameAccount_002, testing::ext::TestSize.Level1) +{ + DmAccessCaller caller; + std::string srcUdid = "srcUdid"; + DmAccessCallee callee; + std::string sinkUdid = "sinkUdid"; + + EXPECT_CALL(*deviceProfileConnectorMock_, CheckSinkIsSameAccount(_, _, _, _)) + .WillOnce(Return(false)); + + bool ret = deviceManagerServiceImpl_->CheckSinkIsSameAccount(caller, srcUdid, callee, sinkUdid); + EXPECT_FALSE(ret); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, SetBindCallerInfoToBindParam_001, testing::ext::TestSize.Level1) +{ + std::map bindParam = { + {"key1", "value1"}, + {"key2", "value2"} + }; + std::map bindParamTmp; + DmBindCallerInfo bindCallerInfo; + bindCallerInfo.userId = 100; + bindCallerInfo.tokenId = 200; + bindCallerInfo.bindLevel = 2; + bindCallerInfo.bundleName = "bundle"; + bindCallerInfo.hostPkgLabel = "label"; + bindCallerInfo.processName = "proc"; + bindCallerInfo.isSystemSA = true; + + deviceManagerServiceImpl_->SetBindCallerInfoToBindParam(bindParam, bindParamTmp, bindCallerInfo); + + EXPECT_EQ(bindParamTmp["key1"], "value1"); + EXPECT_EQ(bindParamTmp["key2"], "value2"); + + EXPECT_EQ(bindParamTmp["bindCallerUserId"], "100"); + EXPECT_EQ(bindParamTmp["bindCallerTokenId"], "200"); + EXPECT_EQ(bindParamTmp["bindCallerBindLevel"], "2"); + EXPECT_EQ(bindParamTmp["bindCallerBundleName"], "bundle"); + EXPECT_EQ(bindParamTmp["bindCallerHostPkgLabel"], "label"); + EXPECT_EQ(bindParamTmp["bindCallerProcessName"], "proc"); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, TransferOldAuthMgr_001, testing::ext::TestSize.Level1) +{ + deviceManagerServiceImpl_->authMgr_ = nullptr; + int32_t msgtype = 80; + JsonObject jsonObject; + int32_t sessionId = 12345; + std::string deviceid = "LN0000"; + std::shared_ptr session = std::make_shared(sessionId, deviceid); + int32_t ret = deviceManagerServiceImpl_->TransferOldAuthMgr(msgtype, jsonObject, session); + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, GetCurSession_001, testing::ext::TestSize.Level1) +{ + int sessionId = 123; + std::shared_ptr session = std::make_shared(sessionId, "devId"); + { + std::lock_guard lock(deviceManagerServiceImpl_->mapMutex_); + deviceManagerServiceImpl_->sessionsMap_[sessionId] = session; + } + auto result = deviceManagerServiceImpl_->GetCurSession(sessionId); + EXPECT_EQ(result, session); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, GetCurSession_002, testing::ext::TestSize.Level1) +{ + int sessionId = 456; + { + std::lock_guard lock(deviceManagerServiceImpl_->mapMutex_); + deviceManagerServiceImpl_->sessionsMap_.erase(sessionId); + } + auto result = deviceManagerServiceImpl_->GetCurSession(sessionId); + EXPECT_EQ(result, nullptr); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, SetBindCallerInfoToBindParam_002, testing::ext::TestSize.Level1) +{ + std::map bindParam; + std::map bindParamTmp; + DmBindCallerInfo bindCallerInfo; + bindCallerInfo.userId = 1; + bindCallerInfo.tokenId = 2; + bindCallerInfo.bindLevel = 3; + bindCallerInfo.bundleName = "bundle"; + bindCallerInfo.hostPkgLabel = "label"; + bindCallerInfo.processName = "proc"; + bindCallerInfo.isSystemSA = false; + + deviceManagerServiceImpl_->SetBindCallerInfoToBindParam(bindParam, bindParamTmp, bindCallerInfo); + + EXPECT_EQ(bindParamTmp["bindCallerUserId"], "1"); + EXPECT_EQ(bindParamTmp["bindCallerTokenId"], "2"); + EXPECT_EQ(bindParamTmp["bindCallerBindLevel"], "3"); + EXPECT_EQ(bindParamTmp["bindCallerBundleName"], "bundle"); + EXPECT_EQ(bindParamTmp["bindCallerHostPkgLabel"], "label"); + EXPECT_EQ(bindParamTmp["bindCallerProcessName"], "proc"); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, SetBindCallerInfoToBindParam_003, testing::ext::TestSize.Level1) +{ + std::map bindParam = { + {"originKey", "originValue"} + }; + std::map bindParamTmp; + DmBindCallerInfo bindCallerInfo; + bindCallerInfo.userId = 10; + bindCallerInfo.tokenId = 20; + bindCallerInfo.bindLevel = 30; + bindCallerInfo.bundleName = "bundle2"; + bindCallerInfo.hostPkgLabel = "label2"; + bindCallerInfo.processName = "proc2"; + bindCallerInfo.isSystemSA = true; + + deviceManagerServiceImpl_->SetBindCallerInfoToBindParam(bindParam, bindParamTmp, bindCallerInfo); + + EXPECT_EQ(bindParamTmp["originKey"], "originValue"); + EXPECT_EQ(bindParamTmp["bindCallerUserId"], "10"); + EXPECT_EQ(bindParamTmp["bindCallerTokenId"], "20"); + EXPECT_EQ(bindParamTmp["bindCallerBindLevel"], "30"); + EXPECT_EQ(bindParamTmp["bindCallerBundleName"], "bundle2"); + EXPECT_EQ(bindParamTmp["bindCallerHostPkgLabel"], "label2"); + EXPECT_EQ(bindParamTmp["bindCallerProcessName"], "proc2"); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, TransferSrcOldAuthMgr_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr session = std::make_shared(111, "devId"); + int32_t ret = deviceManagerServiceImpl_->TransferSrcOldAuthMgr(session); + EXPECT_EQ(ret, ERR_DM_AUTH_FAILED); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, ChangeUltrasonicTypeToPin_001, testing::ext::TestSize.Level1) +{ + std::map bindParam; + int32_t ret = deviceManagerServiceImpl_->ChangeUltrasonicTypeToPin(bindParam); + EXPECT_EQ(ret, ERR_DM_AUTH_FAILED); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, ChangeUltrasonicTypeToPin_002, testing::ext::TestSize.Level1) +{ + + std::map bindParam; + bindParam[PARAM_KEY_AUTH_TYPE] = "6"; + int32_t ret = deviceManagerServiceImpl_->ChangeUltrasonicTypeToPin(bindParam); + EXPECT_EQ(ret, DM_OK); + EXPECT_EQ(bindParam[PARAM_KEY_AUTH_TYPE], std::string("1")); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, TransferSrcOldAuthMgr_002, testing::ext::TestSize.Level1) +{ + std::shared_ptr session = std::make_shared(222, "devId"); + uint64_t logicalSessionId = 1001; + uint64_t tokenId = 2002; + deviceManagerServiceImpl_->logicalSessionId2SessionIdMap_[logicalSessionId] = 222; + deviceManagerServiceImpl_->logicalSessionId2TokenIdMap_[logicalSessionId] = tokenId; + deviceManagerServiceImpl_->authMgrMap_.erase(tokenId); + + int32_t ret = deviceManagerServiceImpl_->TransferSrcOldAuthMgr(session); + EXPECT_EQ(ret, ERR_DM_POINT_NULL); + + deviceManagerServiceImpl_->logicalSessionId2SessionIdMap_.clear(); + deviceManagerServiceImpl_->logicalSessionId2TokenIdMap_.clear(); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, TransferOldAuthMgr_002, testing::ext::TestSize.Level1) +{ + int32_t msgType = 90; + JsonObject jsonObject; + jsonObject[TAG_EDITION] = "5.0.90"; + auto session = std::make_shared(2, "devId"); + deviceManagerServiceImpl_->authMgr_ = std::shared_ptr(); + + EXPECT_CALL(*deviceManagerServiceImplMock_, TransferSrcOldAuthMgr(_)).WillOnce(Return(123)); + + int32_t ret = deviceManagerServiceImpl_->TransferOldAuthMgr(msgType, jsonObject, session); + EXPECT_NE(ret, DM_OK); + deviceManagerServiceImpl_->authMgr_ = nullptr; +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, TransferOldAuthMgr_003, testing::ext::TestSize.Level1) +{ + int32_t msgType = 80; + JsonObject jsonObject; + jsonObject[TAG_DMVERSION] = "5.0.90"; + auto session = std::make_shared(3, "devId"); + deviceManagerServiceImpl_->authMgr_ = std::shared_ptr(); + + int32_t ret = deviceManagerServiceImpl_->TransferOldAuthMgr(msgType, jsonObject, session); + EXPECT_NE(ret, DM_OK); + deviceManagerServiceImpl_->authMgr_ = nullptr; +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, GetDeviceInfo_001, testing::ext::TestSize.Level1) +{ + PeerTargetId targetId; + targetId.wifiIp = "192.168.1.100"; + targetId.wifiPort = 12345; + std::string addrType = ""; + std::string deviceId; + auto deviceInfo = std::make_shared(); + int32_t index = 0; + + int32_t ret = deviceManagerServiceImpl_->GetDeviceInfo(targetId, addrType, deviceId, deviceInfo, index); + EXPECT_EQ(ret, DM_OK); + EXPECT_EQ(deviceId, "192.168.1.100"); + EXPECT_EQ(deviceInfo->addr[0].type, ConnectionAddrType::CONNECTION_ADDR_WLAN); + EXPECT_EQ(deviceInfo->addr[0].info.ip.port, 12345); + EXPECT_EQ(index, 1); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, GetDeviceInfo_002, testing::ext::TestSize.Level1) +{ + PeerTargetId targetId; + targetId.wifiIp = "192.168.1.101"; + targetId.wifiPort = 54321; + std::string deviceId; + std::string addrType = std::to_string(ConnectionAddrType::CONNECTION_ADDR_BR); + auto deviceInfo = std::make_shared(); + int32_t index = 0; + + int32_t ret = deviceManagerServiceImpl_->GetDeviceInfo(targetId, addrType, deviceId, deviceInfo, index); + EXPECT_EQ(ret, DM_OK); + EXPECT_EQ(deviceId, "192.168.1.101"); + EXPECT_EQ(deviceInfo->addr[0].type, ConnectionAddrType::CONNECTION_ADDR_BR); + EXPECT_EQ(deviceInfo->addr[0].info.ip.port, 54321); + EXPECT_EQ(index, 1); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, GetDeviceInfo_003, testing::ext::TestSize.Level1) +{ + PeerTargetId targetId; + targetId.brMac = "11:22:33:44:55:66"; + std::string addrType = ""; + std::string deviceId; + auto deviceInfo = std::make_shared(); + int32_t index = 0; + + int32_t ret = deviceManagerServiceImpl_->GetDeviceInfo(targetId, addrType, deviceId, deviceInfo, index); + EXPECT_EQ(ret, DM_OK); + EXPECT_EQ(deviceId, "11:22:33:44:55:66"); + EXPECT_EQ(deviceInfo->addr[0].type, ConnectionAddrType::CONNECTION_ADDR_BR); + EXPECT_EQ(index, 1); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, GetDeviceInfo_004, testing::ext::TestSize.Level1) +{ + PeerTargetId targetId; + targetId.bleMac = "AA:BB:CC:DD:EE:FF"; + targetId.deviceId = "12345678"; + std::string addrType = ""; + std::string deviceId; + auto deviceInfo = std::make_shared(); + int32_t index = 0; + + int32_t ret = deviceManagerServiceImpl_->GetDeviceInfo(targetId, addrType, deviceId, deviceInfo, index); + EXPECT_EQ(ret, DM_OK); + EXPECT_EQ(deviceId, "AA:BB:CC:DD:EE:FF"); + EXPECT_EQ(deviceInfo->addr[0].type, ConnectionAddrType::CONNECTION_ADDR_BLE); + EXPECT_EQ(index, 1); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, GetDeviceInfo_005, testing::ext::TestSize.Level1) +{ + PeerTargetId targetId; + std::string addrType = ""; + std::string deviceId; + auto deviceInfo = std::make_shared(); + int32_t index = 0; + + int32_t ret = deviceManagerServiceImpl_->GetDeviceInfo(targetId, addrType, deviceId, deviceInfo, index); + EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAclByDelProfileMap_001, testing::ext::TestSize.Level1) +{ + + std::map delProfileMap; + std::vector profiles; + DistributedDeviceProfile::AccessControlProfile profile; + const std::string localUdid = "123456"; + profile.GetAccesser().SetAccesserTokenId(5678); + profiles.push_back(profile); + int32_t key = 12; + std::string value = "acl_info1"; + deviceManagerServiceImpl_->DeleteAclByDelProfileMap(delProfileMap, profiles, localUdid); + + EXPECT_FALSE(profiles.empty()); +} } // namespace } // namespace DistributedHardware } // namespace OHOS diff --git a/test/unittest/UTTest_device_manager_service_impl_first.h b/test/unittest/UTTest_device_manager_service_impl_first.h index 04dcec1a1..25a0c2259 100644 --- a/test/unittest/UTTest_device_manager_service_impl_first.h +++ b/test/unittest/UTTest_device_manager_service_impl_first.h @@ -30,6 +30,7 @@ #include "dm_device_state_manager_mock.h" #include "device_manager_service_impl_mock.h" #include "hichain_connector_mock.h" +#include "hichain_auth_connector_mock.h" namespace OHOS { namespace DistributedHardware { @@ -52,8 +53,10 @@ public: std::make_shared(); static inline std::shared_ptr deviceManagerServiceImplMock_ = std::make_shared(); - static inline std::shared_ptr hiChainConnectorMock_ = + static inline std::shared_ptr hiChainConnectorMock_ = std::make_shared(); + static inline std::shared_ptr hiChainAuthConnectorMock_ = + std::make_shared(); }; } // namespace DistributedHardware } // namespace OHOS diff --git a/test/unittest/mock/device_manager_service_impl_mock.cpp b/test/unittest/mock/device_manager_service_impl_mock.cpp index efd5f34ec..29be616df 100644 --- a/test/unittest/mock/device_manager_service_impl_mock.cpp +++ b/test/unittest/mock/device_manager_service_impl_mock.cpp @@ -102,5 +102,31 @@ void DeviceManagerServiceImpl::HandleAppUnBindEvent(int32_t remoteUserId, const DmDeviceManagerServiceImpl::dmDeviceManagerServiceImpl->HandleAppUnBindEvent(remoteUserId, remoteUdid, tokenId, peerTokenId); } + +bool DeviceManagerServiceImpl::IsAuthNewVersion(int32_t bindLevel, std::string localUdid, + std::string remoteUdid, int32_t tokenId, int32_t userId) +{ + return DmDeviceManagerServiceImpl::dmDeviceManagerServiceImpl->IsAuthNewVersion(bindLevel, localUdid, + remoteUdid, tokenId, userId); +} + +int32_t DeviceManagerServiceImpl::DeleteAcl(const std::string &sessionName, const std::string &localUdid, + const std::string &remoteUdid, int32_t bindLevel, const std::string &extra) +{ + return DmDeviceManagerServiceImpl::dmDeviceManagerServiceImpl->DeleteAcl(sessionName, localUdid, remoteUdid, + bindLevel, extra); +} + +int32_t DeviceManagerServiceImpl::DeleteAclForProcV2(const std::string &localUdid, uint32_t localTokenId, + const std::string &remoteUdid, int32_t bindLevel, const std::string &extra, int32_t userId) +{ + return DmDeviceManagerServiceImpl::dmDeviceManagerServiceImpl->DeleteAclForProcV2(localUdid, localTokenId, + remoteUdid, bindLevel, extra, userId); +} + +std::string DeviceManagerServiceImpl::GetBundleLable(const std::string &bundleName) +{ + return DmDeviceManagerServiceImpl::dmDeviceManagerServiceImpl->GetBundleLable(bundleName); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/test/unittest/mock/device_manager_service_impl_mock.h b/test/unittest/mock/device_manager_service_impl_mock.h index 6a31d6008..92bd2dc3c 100644 --- a/test/unittest/mock/device_manager_service_impl_mock.h +++ b/test/unittest/mock/device_manager_service_impl_mock.h @@ -46,6 +46,13 @@ public: virtual void HandleAppUnBindEvent(int32_t remoteUserId, const std::string &remoteUdid, int32_t tokenId) = 0; virtual void HandleAppUnBindEvent(int32_t remoteUserId, const std::string &remoteUdid, int32_t tokenId, int32_t peerTokenId) = 0; + virtual bool IsAuthNewVersion(int32_t bindLevel, std::string localUdid, std::string remoteUdid, + int32_t tokenId, int32_t userId) = 0; + virtual int32_t DeleteAcl(const std::string &sessionName, const std::string &localUdid, + const std::string &remoteUdid, int32_t bindLevel, const std::string &extra) = 0; + virtual int32_t DeleteAclForProcV2(const std::string &localUdid, uint32_t localTokenId, + const std::string &remoteUdid, int32_t bindLevel, const std::string &extra, int32_t userId) = 0; + virtual std::string GetBundleLable(const std::string &bundleName) = 0; public: static inline std::shared_ptr dmDeviceManagerServiceImpl = nullptr; }; @@ -69,6 +76,13 @@ public: MOCK_METHOD(void, HandleAppUnBindEvent, (int32_t remoteUserId, const std::string &remoteUdid, int32_t tokenId)); MOCK_METHOD(void, HandleAppUnBindEvent, (int32_t remoteUserId, const std::string &remoteUdid, int32_t tokenId, int32_t peerTokenId)); + MOCK_METHOD(bool, IsAuthNewVersion, (int32_t bindLevel, std::string localUdid, std::string remoteUdid, + int32_t tokenId, int32_t userId)); + MOCK_METHOD(int32_t, DeleteAcl, (const std::string &sessionName, const std::string &localUdid, + const std::string &remoteUdid, int32_t bindLevel, const std::string &extra)); + MOCK_METHOD(int32_t, DeleteAclForProcV2, (const std::string &localUdid, uint32_t localTokenId, + const std::string &remoteUdid, int32_t bindLevel, const std::string &extra, int32_t userId)); + MOCK_METHOD(std::string, GetBundleLable, (const std::string &bundleName)); }; } } diff --git a/test/unittest/mock/deviceprofile_connector_mock.cpp b/test/unittest/mock/deviceprofile_connector_mock.cpp index 4f82813a2..ae770c772 100644 --- a/test/unittest/mock/deviceprofile_connector_mock.cpp +++ b/test/unittest/mock/deviceprofile_connector_mock.cpp @@ -200,5 +200,67 @@ bool DeviceProfileConnector::IsLnnAcl(const DistributedDeviceProfile::AccessCont { return DmDeviceProfileConnector::dmDeviceProfileConnector->IsLnnAcl(profile); } + +int32_t DeviceProfileConnector::DeleteSessionKey(int32_t userId, int32_t sessionKeyId) +{ + return DmDeviceProfileConnector::dmDeviceProfileConnector->DeleteSessionKey(userId, sessionKeyId); +} +DmOfflineParam DeviceProfileConnector::FilterNeedDeleteACL(const std::string &localDeviceId, uint32_t localTokenId, + const std::string &remoteDeviceId, const std::string &extra) +{ + return DmDeviceProfileConnector::dmDeviceProfileConnector->FilterNeedDeleteACL(localDeviceId, localTokenId, + remoteDeviceId, extra); +} + +void DeviceProfileConnector::UpdateACL(std::string &localUdid, const std::vector &localUserIds, + const std::string &remoteUdid, const std::vector &remoteFrontUserIds, + const std::vector &remoteBackUserIds, DmOfflineParam &offlineParam) +{ + DmDeviceProfileConnector::dmDeviceProfileConnector->UpdateACL(localUdid, localUserIds, + remoteUdid, remoteFrontUserIds, remoteBackUserIds, offlineParam); +} + +void DeviceProfileConnector::HandleSyncBackgroundUserIdEvent( + const std::vector &remoteUserIds, const std::string &remoteUdid, + const std::vector &localUserIds, std::string &localUdid) +{ + DmDeviceProfileConnector::dmDeviceProfileConnector->HandleSyncBackgroundUserIdEvent(remoteUserIds, remoteUdid, + localUserIds, localUdid); +} + +void DeviceProfileConnector::HandleSyncForegroundUserIdEvent( + const std::vector &remoteUserIds, const std::string &remoteUdid, + const std::vector &localUserIds, std::string &localUdid) +{ + DmDeviceProfileConnector::dmDeviceProfileConnector->HandleSyncForegroundUserIdEvent(remoteUserIds, remoteUdid, + localUserIds, localUdid); +} + +bool DeviceProfileConnector::CheckSrcAccessControl(const DmAccessCaller &caller, const std::string &srcUdid, + const DmAccessCallee &callee, const std::string &sinkUdid) +{ + return DmDeviceProfileConnector::dmDeviceProfileConnector->CheckSrcAccessControl(caller, srcUdid, callee, sinkUdid); +} + +bool DeviceProfileConnector::CheckSinkAccessControl(const DmAccessCaller &caller, const std::string &srcUdid, + const DmAccessCallee &callee, const std::string &sinkUdid) +{ + return DmDeviceProfileConnector::dmDeviceProfileConnector->CheckSinkAccessControl(caller, + srcUdid, callee, sinkUdid); +} + +bool DeviceProfileConnector::CheckSrcIsSameAccount(const DmAccessCaller &caller, const std::string &srcUdid, + const DmAccessCallee &callee, const std::string &sinkUdid) +{ + return DmDeviceProfileConnector::dmDeviceProfileConnector->CheckSrcIsSameAccount(caller, + srcUdid, callee, sinkUdid); +} + +bool DeviceProfileConnector::CheckSinkIsSameAccount(const DmAccessCaller &caller, const std::string &srcUdid, + const DmAccessCallee &callee, const std::string &sinkUdid) +{ + return DmDeviceProfileConnector::dmDeviceProfileConnector->CheckSinkIsSameAccount(caller, + srcUdid, callee, sinkUdid); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/test/unittest/mock/deviceprofile_connector_mock.h b/test/unittest/mock/deviceprofile_connector_mock.h index 84d5c9d04..df7e11f89 100644 --- a/test/unittest/mock/deviceprofile_connector_mock.h +++ b/test/unittest/mock/deviceprofile_connector_mock.h @@ -75,6 +75,27 @@ public: virtual void CacheAcerAclId(const DistributedDeviceProfile::AccessControlProfile &profile, std::vector &aclInfos) = 0; virtual bool IsLnnAcl(const DistributedDeviceProfile::AccessControlProfile &profile) = 0; + virtual int32_t DeleteSessionKey(int32_t userId, int32_t sessionKeyId) = 0; + virtual DmOfflineParam FilterNeedDeleteACL(const std::string &localDeviceId, uint32_t localTokenId, + const std::string &remoteDeviceId, const std::string &extra) = 0; + virtual void HandleSyncBackgroundUserIdEvent( + const std::vector &remoteUserIds, const std::string &remoteUdid, + const std::vector &localUserIds, std::string &localUdid) = 0; + virtual void HandleSyncForegroundUserIdEvent( + const std::vector &remoteUserIds, const std::string &remoteUdid, + const std::vector &localUserIds, std::string &localUdid) = 0; + virtual void UpdateACL( + std::string &localUdid, const std::vector &localUserIds, + const std::string &remoteUdid, const std::vector &remoteFrontUserIds, + const std::vector &remoteBackUserIds, DmOfflineParam &offlineParam) = 0; + virtual bool CheckSrcAccessControl(const DmAccessCaller &caller, const std::string &srcUdid, + const DmAccessCallee &callee, const std::string &sinkUdid) = 0; + virtual bool CheckSinkAccessControl(const DmAccessCaller &caller, const std::string &srcUdid, + const DmAccessCallee &callee, const std::string &sinkUdid) = 0; + virtual bool CheckSrcIsSameAccount(const DmAccessCaller &caller, const std::string &srcUdid, + const DmAccessCallee &callee, const std::string &sinkUdid) = 0; + virtual bool CheckSinkIsSameAccount(const DmAccessCaller &caller, const std::string &srcUdid, + const DmAccessCallee &callee, const std::string &sinkUdid) = 0; public: static inline std::shared_ptr dmDeviceProfileConnector = nullptr; }; @@ -124,6 +145,26 @@ public: MOCK_METHOD(void, CacheAcerAclId, (const DistributedDeviceProfile::AccessControlProfile &profile, std::vector &aclInfos)); MOCK_METHOD(bool, IsLnnAcl, (const DistributedDeviceProfile::AccessControlProfile &profile)); + MOCK_METHOD(int32_t, DeleteSessionKey, (int32_t userId, int32_t sessionKeyId)); + MOCK_METHOD(DmOfflineParam, FilterNeedDeleteACL, (const std::string &localDeviceId, uint32_t localTokenId, + const std::string &remoteDeviceId, const std::string &extra)); + MOCK_METHOD(void, UpdateACL, (std::string &localUdid, const std::vector &localUserIds, + const std::string &remoteUdid, const std::vector &remoteFrontUserIds, + const std::vector &remoteBackUserIds, DmOfflineParam &offlineParam)); + MOCK_METHOD(void, HandleSyncBackgroundUserIdEvent, + (const std::vector &remoteUserIds, const std::string &remoteUdid, + const std::vector &localUserIds, std::string &localUdid)); + MOCK_METHOD(void, HandleSyncForegroundUserIdEvent, + (const std::vector &remoteUserIds, const std::string &remoteUdid, + const std::vector &localUserIds, std::string &localUdid)); + MOCK_METHOD(bool, CheckSrcAccessControl, (const DmAccessCaller &caller, const std::string &srcUdid, + const DmAccessCallee &callee, const std::string &sinkUdid)); + MOCK_METHOD(bool, CheckSinkAccessControl, (const DmAccessCaller &caller, const std::string &srcUdid, + const DmAccessCallee &callee, const std::string &sinkUdid)); + MOCK_METHOD(bool, CheckSrcIsSameAccount, (const DmAccessCaller &caller, const std::string &srcUdid, + const DmAccessCallee &callee, const std::string &sinkUdid)); + MOCK_METHOD(bool, CheckSinkIsSameAccount, (const DmAccessCaller &caller, const std::string &srcUdid, + const DmAccessCallee &callee, const std::string &sinkUdid)); }; } } diff --git a/test/unittest/mock/multiple_user_connector_mock.cpp b/test/unittest/mock/multiple_user_connector_mock.cpp index 5d19450cb..b8ac46647 100644 --- a/test/unittest/mock/multiple_user_connector_mock.cpp +++ b/test/unittest/mock/multiple_user_connector_mock.cpp @@ -68,5 +68,15 @@ void MultipleUserConnector::GetCallerUserId(int32_t &userId) { return DmMultipleUserConnector::dmMultipleUserConnector->GetCallerUserId(userId); } + +void MultipleUserConnector::GetCallingTokenId(uint32_t &tokenId) +{ + return DmMultipleUserConnector::dmMultipleUserConnector->GetCallingTokenId(tokenId); +} + +void MultipleUserConnector::ClearLockedUser(std::vector &foregroundUserVec) +{ + return DmMultipleUserConnector::dmMultipleUserConnector->ClearLockedUser(foregroundUserVec); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/test/unittest/mock/multiple_user_connector_mock.h b/test/unittest/mock/multiple_user_connector_mock.h index 9a39bb1b0..1de714228 100644 --- a/test/unittest/mock/multiple_user_connector_mock.h +++ b/test/unittest/mock/multiple_user_connector_mock.h @@ -36,6 +36,8 @@ public: virtual std::string GetOhosAccountIdByUserId(int32_t userId) = 0; virtual std::string GetAccountNickName(int32_t) = 0; virtual void GetCallerUserId(int32_t &) = 0; + virtual void GetCallingTokenId(uint32_t &tokenId) = 0; + virtual void ClearLockedUser(std::vector &foregroundUserVec) = 0; public: static inline std::shared_ptr dmMultipleUserConnector = nullptr; }; @@ -52,6 +54,8 @@ public: MOCK_METHOD(std::string, GetOhosAccountIdByUserId, (int32_t)); MOCK_METHOD(std::string, GetAccountNickName, (int32_t)); MOCK_METHOD(void, GetCallerUserId, (int32_t &)); + MOCK_METHOD(void, GetCallingTokenId, (uint32_t &)); + MOCK_METHOD(void, ClearLockedUser, (std::vector &foregroundUserVec)); }; } } diff --git a/test/unittest/mock/softbus_connector_mock.cpp b/test/unittest/mock/softbus_connector_mock.cpp index d49c8c253..0d59a9b9c 100644 --- a/test/unittest/mock/softbus_connector_mock.cpp +++ b/test/unittest/mock/softbus_connector_mock.cpp @@ -59,5 +59,10 @@ int32_t SoftbusConnector::SyncLocalAclListProcess(const DevUserInfo &localDevUse return DmSoftbusConnector::dmSoftbusConnector->SyncLocalAclListProcess(localDevUserInfo, remoteDevUserInfo, remoteAclList); } + +void SoftbusConnector::HandleDeviceOffline(std::string deviceId) +{ + DmSoftbusConnector::dmSoftbusConnector->HandleDeviceOffline(deviceId); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/test/unittest/mock/softbus_connector_mock.h b/test/unittest/mock/softbus_connector_mock.h index e71d229f6..5d45736e5 100644 --- a/test/unittest/mock/softbus_connector_mock.h +++ b/test/unittest/mock/softbus_connector_mock.h @@ -35,6 +35,7 @@ public: virtual void SetProcessInfoVec(std::vector processInfoVec) = 0; virtual int32_t SyncLocalAclListProcess(const DevUserInfo &localDevUserInfo, const DevUserInfo &remoteDevUserInfo, std::string remoteAclList) = 0; + virtual void HandleDeviceOffline(std::string deviceId) = 0; public: static inline std::shared_ptr dmSoftbusConnector = nullptr; @@ -50,6 +51,7 @@ public: MOCK_METHOD(void, SetProcessInfo, (ProcessInfo processInfo)); MOCK_METHOD(void, SetProcessInfoVec, (std::vector processInfoVec)); MOCK_METHOD(int32_t, SyncLocalAclListProcess, (const DevUserInfo &, const DevUserInfo &, std::string)); + MOCK_METHOD(void, HandleDeviceOffline, (std::string deviceId)); }; } } -- Gitee From e075ec70cf8cade397b5c80d52cb3e0e585b37d7 Mon Sep 17 00:00:00 2001 From: BrainL Date: Fri, 13 Jun 2025 15:11:48 +0800 Subject: [PATCH 2/2] modify Signed-off-by: BrainL --- common/include/dm_anonymous.h | 1 + common/include/dm_constants.h | 2 + common/include/dm_error_type.h | 1 + common/src/dm_anonymous.cpp | 7 + common/src/dm_constants.cpp | 2 + .../include/authentication_v2/auth_manager.h | 2 + .../authentication_v2/dm_auth_context.h | 2 + .../dm_auth_message_processor.h | 1 + .../include/authentication_v2/dm_auth_state.h | 2 + .../src/authentication_v2/auth_manager.cpp | 41 ++++ .../auth_stages/auth_negotiate.cpp | 62 ++++++ .../dm_auth_message_processor.cpp | 44 ++-- test/unittest/BUILD.gn | 33 +++ test/unittest/UTTest_auth_manager.cpp | 200 ++++++++++++++++++ test/unittest/UTTest_auth_manager.h | 48 +++++ test/unittest/UTTest_auth_negotiate.cpp | 161 ++++++++++++++ test/unittest/UTTest_auth_negotiate.h | 4 + .../UTTest_dm_auth_message_processor.cpp | 84 ++++++++ ...distributed_device_profile_client_mock.cpp | 10 + .../distributed_device_profile_client_mock.h | 4 + 20 files changed, 695 insertions(+), 16 deletions(-) create mode 100644 test/unittest/UTTest_auth_manager.cpp create mode 100644 test/unittest/UTTest_auth_manager.h diff --git a/common/include/dm_anonymous.h b/common/include/dm_anonymous.h index 46a5734f6..f6ba0fdd8 100644 --- a/common/include/dm_anonymous.h +++ b/common/include/dm_anonymous.h @@ -107,6 +107,7 @@ DM_EXPORT std::string SafetyDump(const JsonItemObject &jsonObj); std::string GetSubStr(const std::string &rawStr, const std::string &separator, int32_t index); bool IsJsonValIntegerString(const JsonItemObject &jsonObj, const std::string &key); std::string GetAnonyJsonString(const std::string &value); +int64_t GetCurrentTimestamp(); } // namespace DistributedHardware } // namespace OHOS #endif // OHOS_DM_ANONYMOUS_H diff --git a/common/include/dm_constants.h b/common/include/dm_constants.h index 98484ad06..ef2572271 100755 --- a/common/include/dm_constants.h +++ b/common/include/dm_constants.h @@ -159,6 +159,8 @@ DM_EXPORT extern const char* CONN_SESSION_TYPE_HML; DM_EXPORT extern const char* CONN_SESSION_TYPE_BLE; DM_EXPORT extern const char* UN_BIND_PARAM_UDID_KEY; +DM_EXPORT extern const char* DM_BUSINESS_ID; + // screen state enum ScreenState { DM_SCREEN_UNKNOWN = -1, diff --git a/common/include/dm_error_type.h b/common/include/dm_error_type.h index cd5225aed..6e6552ca3 100644 --- a/common/include/dm_error_type.h +++ b/common/include/dm_error_type.h @@ -142,6 +142,7 @@ enum { ERR_DM_VERIFY_SAME_ACCOUNT_FAILED = 969298353, ERR_DM_DEVICE_FREEZED = 969298355, ERR_DM_SOCKET_IN_USED = 969298356, + ERR_DM_ANTI_DISTURB_MODE = 969298357, }; } // namespace DistributedHardware } // namespace OHOS diff --git a/common/src/dm_anonymous.cpp b/common/src/dm_anonymous.cpp index 57edca138..69b50d5cc 100644 --- a/common/src/dm_anonymous.cpp +++ b/common/src/dm_anonymous.cpp @@ -459,5 +459,12 @@ std::string GetAnonyJsonString(const std::string &value) } return paramJson.Dump(); } + +int64_t GetCurrentTimestamp() +{ + auto now = std::chrono::system_clock::now(); + auto duration = std::chrono::duration_cast(now.time_since_epoch()); + return duration.count(); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/common/src/dm_constants.cpp b/common/src/dm_constants.cpp index f70b2272f..fe35b8f0f 100644 --- a/common/src/dm_constants.cpp +++ b/common/src/dm_constants.cpp @@ -149,6 +149,8 @@ const char* CONN_SESSION_TYPE_HML = "HML"; const char* CONN_SESSION_TYPE_BLE = "BLE"; const char* UN_BIND_PARAM_UDID_KEY = "udidKey"; +const char* DM_BUSINESS_ID = "business_id"; + // errCode map const std::map MAP_ERROR_CODE = { { ERR_DM_TIME_OUT, 96929745 }, { ERR_DM_UNSUPPORTED_AUTH_TYPE, 96929760 }, { ERR_DM_AUTH_BUSINESS_BUSY, 96929761 }, diff --git a/services/implementation/include/authentication_v2/auth_manager.h b/services/implementation/include/authentication_v2/auth_manager.h index 2767c79b4..1c5395dfe 100644 --- a/services/implementation/include/authentication_v2/auth_manager.h +++ b/services/implementation/include/authentication_v2/auth_manager.h @@ -123,6 +123,8 @@ public: void PrepareSoftbusSessionCallback(); void DeleteTimer(); + int32_t HandleBusinessEvents(const std::string &businessId, int32_t action); + protected: std::shared_ptr context_; std::mutex bindParamMutex_; diff --git a/services/implementation/include/authentication_v2/dm_auth_context.h b/services/implementation/include/authentication_v2/dm_auth_context.h index c007f4ae5..c2212ab40 100644 --- a/services/implementation/include/authentication_v2/dm_auth_context.h +++ b/services/implementation/include/authentication_v2/dm_auth_context.h @@ -20,6 +20,7 @@ #include "access_control_profile.h" #include "authentication.h" +#include "auth_manager.h" #include "auth_ui_state_manager.h" #include "dm_ability_manager.h" #include "dm_anonymous.h" @@ -202,6 +203,7 @@ struct DmAuthContext { bool successFinished{false}; bool isAppCredentialVerified{false}; // Whether the application credential has been verified bool hmlEnable160M{false}; + std::string businessId; std::string pkgName; // Business-provided identifier, custom-defined by business, carries risk of spoofing std::string pkgLabel; std::string importCodeBundleName; // Bundle name for imported PIN code diff --git a/services/implementation/include/authentication_v2/dm_auth_message_processor.h b/services/implementation/include/authentication_v2/dm_auth_message_processor.h index 0183ac559..0e6987f98 100644 --- a/services/implementation/include/authentication_v2/dm_auth_message_processor.h +++ b/services/implementation/include/authentication_v2/dm_auth_message_processor.h @@ -322,6 +322,7 @@ private: DmAccess &accessTmp); void ParseUltrasonicSide(const JsonObject &jsonObject, std::shared_ptr context); void ParseCert(const JsonObject &jsonObject, std::shared_ptr context); + void ParseAccesserInfo(const JsonObject &jsonObject, std::shared_ptr context); std::shared_ptr cryptoMgr_ = nullptr; std::unordered_map createMessageFuncMap_; std::unordered_map paraseMessageFuncMap_; diff --git a/services/implementation/include/authentication_v2/dm_auth_state.h b/services/implementation/include/authentication_v2/dm_auth_state.h index e729ae5dd..87ebc199c 100644 --- a/services/implementation/include/authentication_v2/dm_auth_state.h +++ b/services/implementation/include/authentication_v2/dm_auth_state.h @@ -477,6 +477,8 @@ private: JsonObject &credTypeJson); void GetSinkCredTypeForP2P(std::shared_ptr context, const JsonItemObject &credObj, JsonObject &aclInfo, JsonObject &credTypeJson, int32_t credType, std::vector &deleteCredInfo); + bool IsAntiDisturbanceMode(const std::string &businessId); + bool ParseAndCheckAntiDisturbanceMode(const std::string &businessId, const std::string &businessValue); }; class AuthSinkDataSyncState : public DmAuthState { diff --git a/services/implementation/src/authentication_v2/auth_manager.cpp b/services/implementation/src/authentication_v2/auth_manager.cpp index 88668d9dd..16c55a780 100644 --- a/services/implementation/src/authentication_v2/auth_manager.cpp +++ b/services/implementation/src/authentication_v2/auth_manager.cpp @@ -24,6 +24,10 @@ #include "multiple_user_connector.h" #include "auth_manager.h" +#include "business_event.h" +#include "distributed_device_profile_client.h" +#include "dm_auth_cert.h" +#include "dm_auth_attest_common.h" #include "dm_constants.h" #include "dm_crypto.h" #include "dm_random.h" @@ -36,6 +40,7 @@ #include "dm_auth_context.h" #include "dm_auth_message_processor.h" #include "dm_auth_state.h" +#include "json_object.h" namespace OHOS { namespace DistributedHardware { @@ -46,6 +51,9 @@ constexpr int32_t MAX_PIN_CODE = 999999; constexpr int32_t DM_ULTRASONIC_FORWARD = 0; constexpr int32_t DM_ULTRASONIC_REVERSE = 1; const char* IS_NEED_JOIN_LNN = "IsNeedJoinLnn"; +const char* DM_REJECT_KEY = "business_id_cast+_reject_event"; +const char* DM_AUTH_DIALOG_REJECT = "is_auth_dialog_reject"; +const char* DM_TIMESTAMP = "timestamp"; int32_t GetCloseSessionDelaySeconds(std::string &delaySecondsStr) { @@ -135,6 +143,7 @@ AuthManager::AuthManager(std::shared_ptr softbusConnector, context_->accessee.dmVersion = DM_CURRENT_VERSION; context_->timer = std::make_shared(); context_->authMessageProcessor = std::make_shared(); + context_->businessId = ""; } AuthManager::~AuthManager() @@ -415,6 +424,9 @@ std::string AuthManager::GetBundleName(const JsonObject &jsonObject) void AuthManager::ParseJsonObject(const JsonObject &jsonObject) { + if (IsString(jsonObject, DM_BUSINESS_ID)) { + context_->businessId = jsonObject[DM_BUSINESS_ID].Get(); + } if (jsonObject[APP_OPERATION_KEY].IsString()) { context_->appOperation = jsonObject[APP_OPERATION_KEY].Get(); } @@ -727,6 +739,16 @@ int32_t AuthSinkManager::OnUserOperation(int32_t action, const std::string ¶ return ERR_DM_AUTH_NOT_START; } + std::string businessId = context_->businessId; + if (!businessId.empty()) { + LOGI("AuthSinkManager::OnUserOperation found businessId: %{public}s", businessId.c_str()); + int32_t ret = HandleBusinessEvents(businessId, action); + if (ret != DM_OK) { + LOGE("AuthSinkManager::OnUserOperation failed to handle business events, ret: %{public}d", ret); + return ret; + } + } + switch (action) { case USER_OPERATION_TYPE_CANCEL_AUTH: case USER_OPERATION_TYPE_ALLOW_AUTH: @@ -1080,5 +1102,24 @@ void AuthManager::DeleteTimer() } LOGI("end."); } + +int32_t AuthManager::HandleBusinessEvents(const std::string &businessId, int32_t action) +{ + LOGI("AuthManager::HandleBusinessEvents start."); + DistributedDeviceProfile::BusinessEvent rejectEvent; + rejectEvent.SetBusinessKey(DM_REJECT_KEY); + JsonObject rejectJson; + rejectJson[DM_BUSINESS_ID] = businessId; + rejectJson[DM_AUTH_DIALOG_REJECT] = (action == USER_OPERATION_TYPE_CANCEL_AUTH); + rejectJson[DM_TIMESTAMP] = std::to_string(GetCurrentTimestamp()); + rejectEvent.SetBusinessValue(rejectJson.Dump()); + int32_t ret = DistributedDeviceProfile::DistributedDeviceProfileClient::GetInstance().PutBusinessEvent(rejectEvent); + if (ret != DM_OK) { + LOGE("HandleBusinessEvents failed to store reject_event, ret: %{public}d", ret); + return ret; + } + LOGI("HandleBusinessEvents successfully stored reject_event."); + return DM_OK; +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/services/implementation/src/authentication_v2/auth_stages/auth_negotiate.cpp b/services/implementation/src/authentication_v2/auth_stages/auth_negotiate.cpp index 34f9d2967..976ca15f8 100644 --- a/services/implementation/src/authentication_v2/auth_stages/auth_negotiate.cpp +++ b/services/implementation/src/authentication_v2/auth_stages/auth_negotiate.cpp @@ -22,6 +22,8 @@ #include "accessee.h" #include "auth_manager.h" #include "app_manager.h" +#include "business_event.h" +#include "distributed_device_profile_client.h" #include "dm_auth_cert.h" #include "dm_auth_attest_common.h" #include "dm_crypto.h" @@ -48,6 +50,10 @@ using namespace OHOS::Security::AccessToken; namespace OHOS { namespace DistributedHardware { +namespace { + const char* DM_DISTURBANCE_EVENT_KEY = "business_id_cast+_disturbance_event"; + const char* DM_ANTI_DISTURBANCE_MODE = "is_in_anti_disturbance_mode"; +} DmAuthStateType AuthSrcStartState::GetStateType() { @@ -185,6 +191,11 @@ int32_t AuthSinkNegotiateStateMachine::ProcRespNegotiate5_1_0(std::shared_ptr context) { LOGI("AuthSinkNegotiateStateMachine::Action sessionid %{public}d", context->sessionId); + if (IsAntiDisturbanceMode(context->businessId)) { + LOGI("Sink is AntiDisturbMode."); + context->reason = ERR_DM_ANTI_DISTURB_MODE; + return ERR_DM_ANTI_DISTURB_MODE; + } if (FreezeProcess::GetInstance().IsFreezed(context->accessee.bundleName, context->accessee.deviceType)) { LOGE("Device is Freezed"); return ERR_DM_DEVICE_FREEZED; @@ -536,5 +547,56 @@ void AuthSinkNegotiateStateMachine::GetP2PCredentialInfo(std::shared_ptr(); + if (parsedBusinessId != businessId) { + LOGE("AuthManager::IsAntiDisturbMode failed: businessId mismatch. Expected: %{public}s, Found: %{public}s", + businessId.c_str(), parsedBusinessId.c_str()); + return false; + } + if (!jsonObject.Contains(DM_ANTI_DISTURBANCE_MODE) || !jsonObject[DM_ANTI_DISTURBANCE_MODE].IsBoolean()) { + LOGE("AuthManager::IsAntiDisturbMode failed: 'is_in_anti_disturbance_mode' field is missing or invalid."); + return false; + } + bool isInAntiDisturbanceMode = jsonObject[DM_ANTI_DISTURBANCE_MODE].Get(); + LOGI("AuthManager::IsAntiDisturbMode result: %{public}s", isInAntiDisturbanceMode ? "true" : "false"); + + return isInAntiDisturbanceMode; +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/services/implementation/src/authentication_v2/dm_auth_message_processor.cpp b/services/implementation/src/authentication_v2/dm_auth_message_processor.cpp index 2dbaeb495..03712b2b4 100644 --- a/services/implementation/src/authentication_v2/dm_auth_message_processor.cpp +++ b/services/implementation/src/authentication_v2/dm_auth_message_processor.cpp @@ -653,6 +653,9 @@ int32_t DmAuthMessageProcessor::CreateNegotiateMessage(std::shared_ptraccessee.pkgName; jsonObject[TAG_HOST_PKGLABEL] = context->pkgLabel; + if (!context->businessId.empty()) { + jsonObject[DM_BUSINESS_ID] = context->businessId; + } return DM_OK; } @@ -974,14 +977,36 @@ int32_t DmAuthMessageProcessor::ParseNegotiateMessage( context->logicalSessionId = jsonObject[DM_TAG_LOGICAL_SESSION_ID].Get(); context->requestId = static_cast(context->logicalSessionId); } + if (IsString(jsonObject, TAG_PEER_PKG_NAME)) { + context->accessee.pkgName = jsonObject[TAG_PEER_PKG_NAME].Get(); + } + if (IsString(jsonObject, TAG_PEER_BUNDLE_NAME_V2)) { + context->accessee.bundleName = jsonObject[TAG_PEER_BUNDLE_NAME_V2].Get(); + } + if (IsInt32(jsonObject, TAG_PEER_DISPLAY_ID)) { + context->accessee.displayId = jsonObject[TAG_PEER_DISPLAY_ID].Get(); + } + if (IsString(jsonObject, TAG_HOST_PKGLABEL)) { + context->pkgLabel = jsonObject[TAG_HOST_PKGLABEL].Get(); + } + if (IsString(jsonObject, DM_BUSINESS_ID)) { + context->businessId = jsonObject[DM_BUSINESS_ID].Get(); + } + ParseAccesserInfo(jsonObject, context); + ParseUltrasonicSide(jsonObject, context); + ParseCert(jsonObject, context); + context->authStateMachine->TransitionTo(std::make_shared()); + return DM_OK; +} + +void DmAuthMessageProcessor::ParseAccesserInfo(const JsonObject &jsonObject, + std::shared_ptr context) +{ if (jsonObject[TAG_PKG_NAME].IsString()) { context->pkgName = jsonObject[TAG_PKG_NAME].Get(); context->accesser.pkgName = context->pkgName; context->accessee.pkgName = context->accesser.pkgName; } - if (jsonObject[TAG_PEER_PKG_NAME].IsString()) { - context->accessee.pkgName = jsonObject[TAG_PEER_PKG_NAME].Get(); - } if (jsonObject[TAG_DM_VERSION_V2].IsString()) { context->accesser.dmVersion = jsonObject[TAG_DM_VERSION_V2].Get(); } @@ -1003,19 +1028,6 @@ int32_t DmAuthMessageProcessor::ParseNegotiateMessage( if (jsonObject[TAG_EXTRA_INFO].IsString()) { context->accesser.extraInfo = jsonObject[TAG_EXTRA_INFO].Get(); } - - if (jsonObject[TAG_PEER_BUNDLE_NAME_V2].IsString()) { - context->accessee.bundleName = jsonObject[TAG_PEER_BUNDLE_NAME_V2].Get(); - } - if (jsonObject[TAG_PEER_DISPLAY_ID].IsNumberInteger()) { - context->accessee.displayId = jsonObject[TAG_PEER_DISPLAY_ID].Get(); - } - if (IsString(jsonObject, TAG_HOST_PKGLABEL)) { - context->pkgLabel = jsonObject[TAG_HOST_PKGLABEL].Get(); - } - ParseUltrasonicSide(jsonObject, context); - context->authStateMachine->TransitionTo(std::make_shared()); - return DM_OK; } void DmAuthMessageProcessor::ParseCert(const JsonObject &jsonObject, diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 8e572f9a3..3438965bc 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -24,6 +24,7 @@ group("unittest") { ":UTTest_auth_acl", ":UTTest_auth_confirm", ":UTTest_auth_credential_state", + ":UTTest_auth_manager", ":UTTest_auth_message_processor", ":UTTest_auth_negotiate", ":UTTest_auth_pin_auth_state", @@ -2180,6 +2181,7 @@ ohos_unittest("UTTest_auth_negotiate") { "${devicemanager_path}/test/unittest/mock/accesstoken_kit_mock.cpp", "${devicemanager_path}/test/unittest/mock/softbus_connector_mock.cpp", "${devicemanager_path}/test/unittest/mock/softbus_session_mock.cpp", + "${devicemanager_path}/test/unittest/mock/distributed_device_profile_client_mock.cpp", ] deps = [ ":device_manager_test_common" ] @@ -2201,6 +2203,37 @@ ohos_unittest("UTTest_auth_negotiate") { ## UnitTest UTTest_auth_negotiate }}} +## UnitTest UTTest_auth_manager {{{ + +ohos_unittest("UTTest_auth_manager") { + module_out_path = module_out_path + + include_dirs = [] + + sources = [ + "${devicemanager_path}/test/unittest/UTTest_auth_manager.cpp", + "${devicemanager_path}/test/unittest/mock/distributed_device_profile_client_mock.cpp", + ] + + deps = [ ":device_manager_test_common" ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "access_token:libnativetoken", + "access_token:libtoken_setproc", + "device_auth:deviceauth_sdk", + "device_info_manager:distributed_device_profile_common", + "device_info_manager:distributed_device_profile_sdk", + "dsoftbus:softbus_client", + "ffrt:libffrt", + "googletest:gmock", + "googletest:gmock_main", + "hilog:libhilog", + ] +} + +## UnitTest UTTest_auth_manager }}} + ## UnitTest UTTest_auth_confirm {{{ ohos_unittest("UTTest_auth_confirm") { diff --git a/test/unittest/UTTest_auth_manager.cpp b/test/unittest/UTTest_auth_manager.cpp new file mode 100644 index 000000000..1af89b982 --- /dev/null +++ b/test/unittest/UTTest_auth_manager.cpp @@ -0,0 +1,200 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "UTTest_auth_manager.h" + +#include "distributed_device_profile_client.h" +#include "dm_auth_state.h" + +using namespace testing; +namespace OHOS { +namespace DistributedHardware { + +void AuthManagerTest::SetUp() +{ + softbusConnector = std::make_shared(); + deviceManagerServicelistener = std::make_shared(); + hiChainAuthConnector = std::make_shared(); + hiChainConnector = std::make_shared(); + authManager = std::make_shared(softbusConnector, hiChainConnector, deviceManagerServicelistener, + hiChainAuthConnector); +} + +void AuthManagerTest::TearDown() +{ + softbusConnector = nullptr; + deviceManagerServicelistener = nullptr; + hiChainAuthConnector = nullptr; + hiChainConnector = nullptr; + authManager = nullptr; +} + +void AuthManagerTest::SetUpTestCase() +{ + DistributedDeviceProfile::DpDistributedDeviceProfileClient::dpDistributedDeviceProfileClient = + distributedDeviceProfileClientMock_; +} + +void AuthManagerTest::TearDownTestCase() +{ + DistributedDeviceProfile::DpDistributedDeviceProfileClient::dpDistributedDeviceProfileClient = nullptr; + distributedDeviceProfileClientMock_ = nullptr; +} + +HWTEST_F(AuthManagerTest, HandleBusinessEvents_001, testing::ext::TestSize.Level1) +{ + std::string businessId = "testBusinessId"; + int32_t action = USER_OPERATION_TYPE_CANCEL_AUTH; + EXPECT_CALL(*distributedDeviceProfileClientMock_, + PutBusinessEvent(::testing::_)).WillOnce(::testing::Return(DM_OK)); + + int32_t ret = authManager->HandleBusinessEvents(businessId, action); + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(AuthManagerTest, HandleBusinessEvents_002, testing::ext::TestSize.Level1) +{ + std::string businessId = "testBusinessId"; + int32_t action = USER_OPERATION_TYPE_CANCEL_AUTH; + + EXPECT_CALL(*distributedDeviceProfileClientMock_, + PutBusinessEvent(::testing::_)).WillOnce(::testing::Return(ERR_DM_AUTH_NOT_START)); + + int32_t ret = authManager->HandleBusinessEvents(businessId, action); + EXPECT_EQ(ret, ERR_DM_AUTH_NOT_START); +} + +HWTEST_F(AuthManagerTest, HandleBusinessEvents_003, testing::ext::TestSize.Level1) +{ + std::string businessId = "testBusinessId"; + int32_t action = USER_OPERATION_TYPE_ALLOW_AUTH; + + EXPECT_CALL(*distributedDeviceProfileClientMock_, PutBusinessEvent(::testing::_)) + .WillOnce(::testing::Return(DM_OK)); + + int32_t result = authManager->HandleBusinessEvents(businessId, action); + + EXPECT_EQ(result, DM_OK); +} + +HWTEST_F(AuthManagerTest, HandleBusinessEvents_004, testing::ext::TestSize.Level1) +{ + std::string businessId = ""; + int32_t action = USER_OPERATION_TYPE_CANCEL_AUTH; + + EXPECT_CALL(*distributedDeviceProfileClientMock_, PutBusinessEvent(::testing::_)) + .WillOnce(::testing::Return(DM_OK)); + + int32_t result = authManager->HandleBusinessEvents(businessId, action); + + EXPECT_EQ(result, DM_OK); +} + +HWTEST_F(AuthManagerTest, ParseJsonObject_001, testing::ext::TestSize.Level1) +{ + JsonObject jsonObject; + jsonObject[DM_BUSINESS_ID] = "testBusinessId"; + + authManager->ParseJsonObject(jsonObject); + EXPECT_EQ(jsonObject[DM_BUSINESS_ID].Get(), "testBusinessId"); +} + +HWTEST_F(AuthManagerTest, ParseJsonObject_002, testing::ext::TestSize.Level1) +{ + JsonObject jsonObject; + authManager->ParseJsonObject(jsonObject); + EXPECT_EQ(jsonObject[DM_BUSINESS_ID].Get(), ""); +} + +HWTEST_F(AuthManagerTest, OnUserOperation_001, testing::ext::TestSize.Level1) +{ + int32_t action = UiAction::USER_OPERATION_TYPE_CANCEL_AUTH; + std::string params = "testParams"; + int32_t ret = authManager->OnUserOperation(action, params); + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(AuthManagerTest, OnUserOperation_002, testing::ext::TestSize.Level1) +{ + authManager->SetAuthContext(nullptr); + + int32_t action = USER_OPERATION_TYPE_CANCEL_AUTH; + std::string params = ""; + + int32_t ret = authManager->OnUserOperation(action, params); + + EXPECT_EQ(ret, ERR_DM_AUTH_NOT_START); +} + +HWTEST_F(AuthManagerTest, OnUserOperation_003, testing::ext::TestSize.Level1) +{ + authManager->GetAuthContext()->businessId = ""; + + int32_t action = USER_OPERATION_TYPE_CANCEL_AUTH; + std::string params = ""; + + int32_t ret = authManager->OnUserOperation(action, params); + + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(AuthManagerTest, OnUserOperation_004, testing::ext::TestSize.Level1) +{ + authManager->GetAuthContext()->businessId = "testBusinessId"; + + EXPECT_CALL(*distributedDeviceProfileClientMock_, PutBusinessEvent(::testing::_)) + .WillOnce(::testing::Return(ERR_DM_FAILED)); + + int32_t action = USER_OPERATION_TYPE_CANCEL_AUTH; + std::string params = ""; + + int32_t ret = authManager->OnUserOperation(action, params); + + EXPECT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(AuthManagerTest, OnUserOperation_005, testing::ext::TestSize.Level1) +{ + int32_t action = USER_OPERATION_TYPE_AUTH_CONFIRM_TIMEOUT; + std::string params = ""; + + int32_t ret = authManager->OnUserOperation(action, params); + + EXPECT_EQ(ret, DM_OK); + EXPECT_EQ(authManager->GetAuthContext()->reason, ERR_DM_TIME_OUT); +} + +HWTEST_F(AuthManagerTest, OnUserOperation_006, testing::ext::TestSize.Level1) +{ + int32_t action = USER_OPERATION_TYPE_CANCEL_PINCODE_DISPLAY; + std::string params = ""; + + int32_t ret = authManager->OnUserOperation(action, params); + + EXPECT_EQ(ret, DM_OK); + EXPECT_EQ(authManager->GetAuthContext()->reason, ERR_DM_BIND_USER_CANCEL_PIN_CODE_DISPLAY); +} + +HWTEST_F(AuthManagerTest, OnUserOperation_007, testing::ext::TestSize.Level1) +{ + int32_t action = -1; + std::string params = ""; + + int32_t ret = authManager->OnUserOperation(action, params); + + EXPECT_EQ(ret, DM_OK); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/test/unittest/UTTest_auth_manager.h b/test/unittest/UTTest_auth_manager.h new file mode 100644 index 000000000..e2c0b995d --- /dev/null +++ b/test/unittest/UTTest_auth_manager.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_UTTEST_AUTH_MANAGER_H +#define OHOS_UTTEST_AUTH_MANAGER_H + +#include + +#include "auth_manager.h" +#include "device_manager_service_listener.h" +#include "hichain_connector.h" +#include "softbus_connector.h" +#include "distributed_device_profile_client_mock.h" + +namespace OHOS { +namespace DistributedHardware { +class AuthManagerTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +private: + static inline std::shared_ptr + distributedDeviceProfileClientMock_ = + std::make_shared(); + + std::shared_ptr softbusConnector; + std::shared_ptr deviceManagerServicelistener; + std::shared_ptr hiChainAuthConnector; + std::shared_ptr hiChainConnector; + std::shared_ptr authManager; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif diff --git a/test/unittest/UTTest_auth_negotiate.cpp b/test/unittest/UTTest_auth_negotiate.cpp index 02d4a30d3..8bc9f6123 100644 --- a/test/unittest/UTTest_auth_negotiate.cpp +++ b/test/unittest/UTTest_auth_negotiate.cpp @@ -33,6 +33,8 @@ void AuthNegotiateTest::SetUpTestCase() DmSoftbusConnector::dmSoftbusConnector = softbusConnectorMock; DmSoftbusSession::dmSoftbusSession = softbusSessionMock; + DistributedDeviceProfile::DpDistributedDeviceProfileClient::dpDistributedDeviceProfileClient = + distributedDeviceProfileClientMock_; } void AuthNegotiateTest::TearDownTestCase() @@ -42,6 +44,8 @@ void AuthNegotiateTest::TearDownTestCase() softbusSessionMock = nullptr; DmSoftbusConnector::dmSoftbusConnector = nullptr; DmSoftbusSession::dmSoftbusSession = nullptr; + DistributedDeviceProfile::DpDistributedDeviceProfileClient::dpDistributedDeviceProfileClient = nullptr; + distributedDeviceProfileClientMock_ = nullptr; } void AuthNegotiateTest::SetUp() @@ -61,6 +65,7 @@ void AuthNegotiateTest::SetUp() Mock::VerifyAndClearExpectations(&*softbusConnectorMock); Mock::VerifyAndClearExpectations(&*softbusSessionMock); + Mock::VerifyAndClearExpectations(&*distributedDeviceProfileClientMock_); } void AuthNegotiateTest::TearDown() @@ -77,6 +82,24 @@ void AuthNegotiateTest::TearDown() tokenMock = nullptr; } +int32_t GetBusinessEventMockTrue(DistributedDeviceProfile::BusinessEvent &event) +{ + event.SetBusinessValue("{\"business_id\":\"test_business_id\",\"is_in_anti_disturbance_mode\":true}"); + return DM_OK; +} + +int32_t GetBusinessEventMockEmpty(DistributedDeviceProfile::BusinessEvent &event) +{ + event.SetBusinessValue(""); + return DM_OK; +} + +int32_t GetBusinessEventMockFalse(DistributedDeviceProfile::BusinessEvent &event) +{ + event.SetBusinessValue("{\"business_id\":\"test_business_id\",\"is_in_anti_disturbance_mode\":false}"); + return DM_OK; +} + HWTEST_F(AuthNegotiateTest, AuthSrcStartState_001, testing::ext::TestSize.Level1) { std::shared_ptr authState = std::make_shared(); @@ -221,5 +244,143 @@ HWTEST_F(AuthNegotiateTest, AuthSinkNegotiateStateMachine_008, testing::ext::Tes EXPECT_FALSE(result); } +HWTEST_F(AuthNegotiateTest, AuthSinkNegotiateStateMachine_Action_003, testing::ext::TestSize.Level1) +{ + std::shared_ptr authState = std::make_shared(); + + std::shared_ptr context = std::make_shared(); + context->businessId = "test_business_id"; + + EXPECT_CALL(*distributedDeviceProfileClientMock_, GetBusinessEvent(::testing::_)) + .WillOnce(::testing::Invoke(GetBusinessEventMockTrue)); + + int32_t result = authState->Action(context); + + EXPECT_EQ(result, ERR_DM_ANTI_DISTURB_MODE); + EXPECT_EQ(context->reason, ERR_DM_ANTI_DISTURB_MODE); +} + +HWTEST_F(AuthNegotiateTest, AuthSinkNegotiateStateMachine_Action_004, testing::ext::TestSize.Level1) +{ + std::shared_ptr authState = std::make_shared(); + + std::shared_ptr context = std::make_shared(); + context->businessId = "test_business_id"; + + EXPECT_CALL(*distributedDeviceProfileClientMock_, GetBusinessEvent(::testing::_)) + .WillOnce(::testing::Invoke(GetBusinessEventMockFalse)); + + int32_t result = authState->Action(context); + + EXPECT_NE(result, ERR_DM_ANTI_DISTURB_MODE); + EXPECT_NE(context->reason, ERR_DM_ANTI_DISTURB_MODE); +} + +HWTEST_F(AuthNegotiateTest, IsAntiDisturbanceMode_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr authState = std::make_shared(); + std::string businessId = ""; + businessId.clear(); + EXPECT_FALSE(authState->IsAntiDisturbanceMode(businessId)); +} + +HWTEST_F(AuthNegotiateTest, IsAntiDisturbanceMode_002, testing::ext::TestSize.Level1) +{ + std::shared_ptr authState = std::make_shared(); + std::string businessId = "test_business_id"; + + EXPECT_CALL(*distributedDeviceProfileClientMock_, GetBusinessEvent(::testing::_)) + .WillOnce(::testing::Return(ERR_DM_FAILED)); + + EXPECT_FALSE(authState->IsAntiDisturbanceMode(businessId)); +} + +HWTEST_F(AuthNegotiateTest, IsAntiDisturbanceMode_003, testing::ext::TestSize.Level1) +{ + std::shared_ptr authState = std::make_shared(); + std::string businessId = "test_business_id"; + + EXPECT_CALL(*distributedDeviceProfileClientMock_, GetBusinessEvent(::testing::_)) + .WillOnce(::testing::Invoke(GetBusinessEventMockEmpty)); + + EXPECT_FALSE(authState->IsAntiDisturbanceMode(businessId)); +} + +HWTEST_F(AuthNegotiateTest, IsAntiDisturbanceMode_004, testing::ext::TestSize.Level1) +{ + std::shared_ptr authState = std::make_shared(); + std::string businessId = "test_business_id"; + + EXPECT_CALL(*distributedDeviceProfileClientMock_, GetBusinessEvent(::testing::_)) + .WillOnce(::testing::Invoke(GetBusinessEventMockTrue)); + + EXPECT_TRUE(authState->IsAntiDisturbanceMode(businessId)); +} + +HWTEST_F(AuthNegotiateTest, ParseAndCheckAntiDisturbanceMode_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr authState = std::make_shared(); + std::string businessId = "test_business_id"; + std::string businessValue = "invalid_json"; + EXPECT_FALSE(authState->ParseAndCheckAntiDisturbanceMode(businessId, businessValue)); +} + +HWTEST_F(AuthNegotiateTest, ParseAndCheckAntiDisturbanceMode_002, testing::ext::TestSize.Level1) +{ + std::shared_ptr authState = std::make_shared(); + std::string businessId = "test_business_id"; + std::string businessValue = "{\"is_in_anti_disturbance_mode\":true}"; + EXPECT_FALSE(authState->ParseAndCheckAntiDisturbanceMode(businessId, businessValue)); +} + +HWTEST_F(AuthNegotiateTest, ParseAndCheckAntiDisturbanceMode_003, testing::ext::TestSize.Level1) +{ + std::shared_ptr authState = std::make_shared(); + std::string businessId = "test_business_id"; + std::string businessValue = "{\"business_id\":\"wrong_id\",\"is_in_anti_disturbance_mode\":true}"; + EXPECT_FALSE(authState->ParseAndCheckAntiDisturbanceMode(businessId, businessValue)); +} + +HWTEST_F(AuthNegotiateTest, ParseAndCheckAntiDisturbanceMode_004, testing::ext::TestSize.Level1) +{ + std::shared_ptr authState = std::make_shared(); + std::string businessId = "test_business_id"; + std::string businessValue = "{\"business_id\":\"test_business_id\"}"; + EXPECT_FALSE(authState->ParseAndCheckAntiDisturbanceMode(businessId, businessValue)); +} + +HWTEST_F(AuthNegotiateTest, ParseAndCheckAntiDisturbanceMode_005, testing::ext::TestSize.Level1) +{ + std::shared_ptr authState = std::make_shared(); + std::string businessId = "test_business_id"; + std::string businessValue = "{\"business_id\":\"test_business_id\",\"is_in_anti_disturbance_mode\":true}"; + EXPECT_TRUE(authState->ParseAndCheckAntiDisturbanceMode(businessId, businessValue)); +} + +HWTEST_F(AuthNegotiateTest, ParseAndCheckAntiDisturbanceMode_006, testing::ext::TestSize.Level1) +{ + std::shared_ptr authState = std::make_shared(); + std::string businessId = "test_business_id"; + std::string businessValue = "{\"business_id\":\"test_business_id\",\"is_in_anti_disturbance_mode\":false}"; + EXPECT_FALSE(authState->ParseAndCheckAntiDisturbanceMode(businessId, businessValue)); +} + +HWTEST_F(AuthNegotiateTest, ParseAndCheckAntiDisturbanceMode_007, testing::ext::TestSize.Level1) +{ + std::shared_ptr authState = std::make_shared(); + std::string businessId = "test_business_id"; + std::string businessValue = "{\"business_id\":123,\"is_in_anti_disturbance_mode\":true}"; + + EXPECT_FALSE(authState->ParseAndCheckAntiDisturbanceMode(businessId, businessValue)); +} + +HWTEST_F(AuthNegotiateTest, ParseAndCheckAntiDisturbanceMode_008, testing::ext::TestSize.Level1) +{ + std::shared_ptr authState = std::make_shared(); + std::string businessId = "test_business_id"; + std::string businessValue = "{\"business_id\":\"test_business_id\",\"is_in_anti_disturbance_mode\":123}"; + + EXPECT_FALSE(authState->ParseAndCheckAntiDisturbanceMode(businessId, businessValue)); +} } } \ No newline at end of file diff --git a/test/unittest/UTTest_auth_negotiate.h b/test/unittest/UTTest_auth_negotiate.h index 81608c77d..e3c9ab909 100644 --- a/test/unittest/UTTest_auth_negotiate.h +++ b/test/unittest/UTTest_auth_negotiate.h @@ -21,6 +21,7 @@ #include "accesstoken_kit_mock.h" #include "softbus_connector_mock.h" #include "softbus_session_mock.h" +#include "distributed_device_profile_client_mock.h" namespace OHOS { namespace DistributedHardware { @@ -36,6 +37,9 @@ private: std::make_shared(); static inline std::shared_ptr softbusSessionMock = std::make_shared(); + static inline std::shared_ptr + distributedDeviceProfileClientMock_ = + std::make_shared(); static inline std::shared_ptr tokenMock = nullptr; std::shared_ptr softbusConnector; std::shared_ptr listener; diff --git a/test/unittest/UTTest_dm_auth_message_processor.cpp b/test/unittest/UTTest_dm_auth_message_processor.cpp index fe1f00860..b068f4f00 100644 --- a/test/unittest/UTTest_dm_auth_message_processor.cpp +++ b/test/unittest/UTTest_dm_auth_message_processor.cpp @@ -111,6 +111,90 @@ HWTEST_F(DmAuthMessageProcessorTest, ParseMessageForwardUltrasonicNegotiate_001, EXPECT_EQ(processor->ParseMessageForwardUltrasonicNegotiate(json, context), DM_OK); } +HWTEST_F(DmAuthMessageProcessorTest, ParseNegotiateMessage_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr context = std::make_shared(); + context->authStateMachine = std::make_shared(context); + JsonObject jsonObject; + jsonObject[DM_TAG_LOGICAL_SESSION_ID] = 12345; + + std::shared_ptr processor = std::make_shared(); + int32_t ret = processor->ParseNegotiateMessage(jsonObject, context); + + EXPECT_EQ(ret, DM_OK); + EXPECT_EQ(context->logicalSessionId, 12345); + EXPECT_EQ(context->requestId, 12345); +} + +HWTEST_F(DmAuthMessageProcessorTest, ParseNegotiateMessage_002, testing::ext::TestSize.Level1) +{ + std::shared_ptr context = std::make_shared(); + context->authStateMachine = std::make_shared(context); + JsonObject jsonObject; + jsonObject[TAG_PEER_PKG_NAME] = "testPkgName"; + + std::shared_ptr processor = std::make_shared(); + int32_t ret = processor->ParseNegotiateMessage(jsonObject, context); + + EXPECT_EQ(ret, DM_OK); + EXPECT_EQ(context->accessee.pkgName, "testPkgName"); +} + +HWTEST_F(DmAuthMessageProcessorTest, ParseNegotiateMessage_003, testing::ext::TestSize.Level1) +{ + std::shared_ptr context = std::make_shared(); + context->authStateMachine = std::make_shared(context); + JsonObject jsonObject; + jsonObject[TAG_PEER_BUNDLE_NAME_V2] = "testBundleName"; + + std::shared_ptr processor = std::make_shared(); + int32_t ret = processor->ParseNegotiateMessage(jsonObject, context); + + EXPECT_EQ(ret, DM_OK); + EXPECT_EQ(context->accessee.bundleName, "testBundleName"); +} + +HWTEST_F(DmAuthMessageProcessorTest, ParseNegotiateMessage_004, testing::ext::TestSize.Level1) +{ + std::shared_ptr context = std::make_shared(); + context->authStateMachine = std::make_shared(context); + JsonObject jsonObject; + jsonObject[TAG_PEER_DISPLAY_ID] = 123; + + std::shared_ptr processor = std::make_shared(); + int32_t ret = processor->ParseNegotiateMessage(jsonObject, context); + + EXPECT_EQ(ret, DM_OK); + EXPECT_EQ(context->accessee.displayId, 123); +} + +HWTEST_F(DmAuthMessageProcessorTest, ParseNegotiateMessage_005, testing::ext::TestSize.Level1) +{ + std::shared_ptr context = std::make_shared(); + context->authStateMachine = std::make_shared(context); + JsonObject jsonObject; + jsonObject[TAG_HOST_PKGLABEL] = "testPkgLabel"; + + std::shared_ptr processor = std::make_shared(); + int32_t ret = processor->ParseNegotiateMessage(jsonObject, context); + + EXPECT_EQ(ret, DM_OK); + EXPECT_EQ(context->pkgLabel, "testPkgLabel"); +} + +HWTEST_F(DmAuthMessageProcessorTest, ParseNegotiateMessage_006, testing::ext::TestSize.Level1) +{ + std::shared_ptr context = std::make_shared(); + context->authStateMachine = std::make_shared(context); + JsonObject jsonObject; + jsonObject[DM_BUSINESS_ID] = "testBusinessId"; + + std::shared_ptr processor = std::make_shared(); + int32_t ret = processor->ParseNegotiateMessage(jsonObject, context); + + EXPECT_EQ(ret, DM_OK); + EXPECT_EQ(context->businessId, "testBusinessId"); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/test/unittest/mock/distributed_device_profile_client_mock.cpp b/test/unittest/mock/distributed_device_profile_client_mock.cpp index 89f1b92cd..c67eda3c1 100644 --- a/test/unittest/mock/distributed_device_profile_client_mock.cpp +++ b/test/unittest/mock/distributed_device_profile_client_mock.cpp @@ -86,5 +86,15 @@ int32_t DistributedDeviceProfileClient::GetLocalServiceInfoByBundleAndPinType(co return DpDistributedDeviceProfileClient::dpDistributedDeviceProfileClient->GetLocalServiceInfoByBundleAndPinType( bundleName, pinExchangeType, localServiceInfo); } + +int32_t DistributedDeviceProfileClient::GetBusinessEvent(BusinessEvent &event) +{ + return DpDistributedDeviceProfileClient::dpDistributedDeviceProfileClient->GetBusinessEvent(event); +} + +int32_t DistributedDeviceProfileClient::PutBusinessEvent(const DistributedDeviceProfile::BusinessEvent &event) +{ + return DpDistributedDeviceProfileClient::dpDistributedDeviceProfileClient->PutBusinessEvent(event); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/test/unittest/mock/distributed_device_profile_client_mock.h b/test/unittest/mock/distributed_device_profile_client_mock.h index 2109ca5db..13495ff3a 100644 --- a/test/unittest/mock/distributed_device_profile_client_mock.h +++ b/test/unittest/mock/distributed_device_profile_client_mock.h @@ -40,6 +40,8 @@ public: virtual int32_t UpdateLocalServiceInfo(const LocalServiceInfo& localServiceInfo) = 0; virtual int32_t GetLocalServiceInfoByBundleAndPinType(const std::string& bundleName, int32_t pinExchangeType, LocalServiceInfo& localServiceInfo) = 0; + virtual int32_t GetBusinessEvent(BusinessEvent &event) = 0; + virtual int32_t PutBusinessEvent(const DistributedDeviceProfile::BusinessEvent &event) = 0; public: static inline std::shared_ptr dpDistributedDeviceProfileClient = nullptr; }; @@ -58,6 +60,8 @@ public: MOCK_METHOD(int32_t, DeleteLocalServiceInfo, (const std::string&, int32_t)); MOCK_METHOD(int32_t, UpdateLocalServiceInfo, (const LocalServiceInfo&)); MOCK_METHOD(int32_t, GetLocalServiceInfoByBundleAndPinType, (const std::string&, int32_t, LocalServiceInfo&)); + MOCK_METHOD(int32_t, GetBusinessEvent, (BusinessEvent &event)); + MOCK_METHOD(int32_t, PutBusinessEvent, (const DistributedDeviceProfile::BusinessEvent &event)); }; } } -- Gitee