From af1fad679c43f1500e34b5658b8b257d659a6095 Mon Sep 17 00:00:00 2001 From: gecheng Date: Thu, 7 Aug 2025 16:57:20 +0800 Subject: [PATCH 1/6] =?UTF-8?q?TOKEN=5FHAP=E7=B1=BB=E5=9E=8B=E6=A0=A1?= =?UTF-8?q?=E9=AA=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../service/cloud/cloud_service_impl.cpp | 3 + .../service/object/src/object_manager.cpp | 3 + .../object/src/object_service_impl.cpp | 3 + .../service/test/BUILD.gn | 2 + .../service/test/cloud_data_mock_test.cpp | 57 +++++++++++ .../service/test/object_manager_mock_test.cpp | 94 ++++++++++++++++++- 6 files changed, 159 insertions(+), 3 deletions(-) diff --git a/services/distributeddataservice/service/cloud/cloud_service_impl.cpp b/services/distributeddataservice/service/cloud/cloud_service_impl.cpp index 64ce9ff50..3747384aa 100644 --- a/services/distributeddataservice/service/cloud/cloud_service_impl.cpp +++ b/services/distributeddataservice/service/cloud/cloud_service_impl.cpp @@ -1600,6 +1600,9 @@ std::vector CloudServiceImpl::ConvertCursor(std::shared CloudServiceImpl::HapInfo CloudServiceImpl::GetHapInfo(uint32_t tokenId) { + if (AccessTokenKit::GetTokenTypeFlag(tokenId) != TOKEN_HAP) { + return { 0, 0, ""}; + } HapTokenInfo tokenInfo; int errCode = AccessTokenKit::GetHapTokenInfo(tokenId, tokenInfo); if (errCode != RET_SUCCESS) { diff --git a/services/distributeddataservice/service/object/src/object_manager.cpp b/services/distributeddataservice/service/object/src/object_manager.cpp index 8abb69bbd..c95f16ad8 100644 --- a/services/distributeddataservice/service/object/src/object_manager.cpp +++ b/services/distributeddataservice/service/object/src/object_manager.cpp @@ -1455,6 +1455,9 @@ int32_t ObjectStoreManager::BindAsset(const uint32_t tokenId, const std::string& return true; }); + if (AccessTokenKit::GetTokenTypeFlag(tokenId) != TOKEN_HAP) { + return GeneralError::E_ERROR; + } HapTokenInfo tokenInfo; auto status = AccessTokenKit::GetHapTokenInfo(tokenId, tokenInfo); if (status != RET_SUCCESS) { diff --git a/services/distributeddataservice/service/object/src/object_service_impl.cpp b/services/distributeddataservice/service/object/src/object_service_impl.cpp index 31d8232e0..2fae655cf 100644 --- a/services/distributeddataservice/service/object/src/object_service_impl.cpp +++ b/services/distributeddataservice/service/object/src/object_service_impl.cpp @@ -117,6 +117,9 @@ int32_t ObjectServiceImpl::BindAssetStore(const std::string &bundleName, const s int32_t ObjectServiceImpl::IsContinue(bool &result) { uint32_t tokenId = IPCSkeleton::GetCallingTokenID(); + if (Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(tokenId) != Security::AccessToken::TOKEN_HAP) { + return OBJECT_INNER_ERROR; + } Security::AccessToken::HapTokenInfo tokenInfo; auto status = Security::AccessToken::AccessTokenKit::GetHapTokenInfo(tokenId, tokenInfo); if (status != 0) { diff --git a/services/distributeddataservice/service/test/BUILD.gn b/services/distributeddataservice/service/test/BUILD.gn index 2f050490c..496f55ce8 100644 --- a/services/distributeddataservice/service/test/BUILD.gn +++ b/services/distributeddataservice/service/test/BUILD.gn @@ -128,6 +128,7 @@ ohos_unittest("CloudDataMockTest") { "${data_service_path}/service/cloud/sync_manager.cpp", "${data_service_path}/service/cloud/sync_strategies/network_sync_strategy.cpp", "${data_service_path}/service/test/mock/checker_mock.cpp", + "mock/access_token_mock.cpp", "mock/account_delegate_mock.cpp", "cloud_data_mock_test.cpp", ] @@ -966,6 +967,7 @@ ohos_unittest("ObjectManagerMockTest") { "../object/src/object_service_stub.cpp", "../object/src/object_snapshot.cpp", "../object/src/object_types_utils.cpp", + "mock/access_token_mock.cpp", "mock/account_delegate_mock.cpp", "mock/device_manager_adapter_mock.cpp", "mock/kv_store_nb_delegate_mock.cpp", diff --git a/services/distributeddataservice/service/test/cloud_data_mock_test.cpp b/services/distributeddataservice/service/test/cloud_data_mock_test.cpp index 0e02096dd..0598f4b8c 100644 --- a/services/distributeddataservice/service/test/cloud_data_mock_test.cpp +++ b/services/distributeddataservice/service/test/cloud_data_mock_test.cpp @@ -25,6 +25,7 @@ #include "ipc_skeleton.h" #include "log_print.h" #include "metadata/meta_data_manager.h" +#include "mock/access_token_mock.h" #include "mock/account_delegate_mock.h" #include "mock/db_store_mock.h" #include "network_delegate_mock.h" @@ -33,6 +34,7 @@ using namespace testing::ext; using namespace testing; using namespace DistributedDB; using namespace OHOS::DistributedData; +using namespace OHOS::Security::AccessToken; using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter; namespace OHOS::Test { @@ -52,6 +54,7 @@ public: void SetUp(); void TearDown(); + static inline std::shared_ptr accTokenMock = nullptr; static SchemaMeta schemaMeta_; static std::shared_ptr cloudServiceImpl_; @@ -185,6 +188,11 @@ void CloudDataMockTest::SetUpTestCase(void) } // 2 means that the GetUserByToken interface will be called twice EXPECT_CALL(*accountDelegateMock, GetUserByToken(_)).Times(2).WillRepeatedly(Return(0)); + + accTokenMock = std::make_shared(); + BAccessTokenKit::accessTokenkit = accTokenMock; + EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(_)).Times(3).WillRepeatedly(Return(ATokenTypeEnum::TOKEN_HAP)); + MetaDataManager::GetInstance().Initialize(dbStoreMock_, nullptr, ""); MetaDataManager::GetInstance().SetSyncer( [](const auto &, auto) { DeviceMatrix::GetInstance().OnChanged(DeviceMatrix::META_STORE_MASK); }); @@ -212,6 +220,8 @@ void CloudDataMockTest::TearDownTestCase() delete accountDelegateMock; accountDelegateMock = nullptr; } + accTokenMock = nullptr; + BAccessTokenKit::accessTokenkit = nullptr; } void CloudDataMockTest::SetUp() @@ -327,6 +337,7 @@ HWTEST_F(CloudDataMockTest, OnReadyTest_LoginAccount, TestSize.Level0) { ZLOGI("CloudDataMockTest OnReadyTest_LoginAccount start"); std::string device = "test"; + EXPECT_CALL(*accountDelegateMock, QueryForegroundUsers(_)).WillRepeatedly(testing::Return(false)); auto ret = cloudServiceImpl_->OnReady(device); EXPECT_EQ(ret, CloudData::CloudService::SUCCESS); @@ -339,5 +350,51 @@ HWTEST_F(CloudDataMockTest, OnReadyTest_LoginAccount, TestSize.Level0) EXPECT_EQ(ret, CloudData::CloudService::SUCCESS); ZLOGI("CloudDataMockTest OnReadyTest_LoginAccount end"); } + + +/** +* @tc.name: GetHapInfo001 +* @tc.desc: Test GetHapInfo function when GetTokenTypeFlag is not TOKEN_HAP. +* @tc.type: FUNC +* @tc.require: + */ +HWTEST_F(CloudDataMockTest, GetHapInfo001, TestSize.Level1) +{ + ZLOGI("CloudDataMockTest GetHapInfo001 start"); + DistributedRdb::PredicatesMemo predicates; + predicates.tables_.push_back(TEST_CLOUD_BUNDLE); + std::vector columns; + CloudData::Participants participants; + EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(_)) + .Times(1) + .WillOnce(Return(ATokenTypeEnum::TOKEN_NATIVE)); + auto [ret, _] = cloudServiceImpl_->AllocResourceAndShare(TEST_CLOUD_STORE, predicates, columns, participants); + EXPECT_EQ(ret, E_ERROR); + ZLOGI("CloudDataMockTest GetHapInfo001 end"); +} + +/** +* @tc.name: GetHapInfo002 +* @tc.desc: Test GetHapInfo function when GetTokenTypeFlag is TOKEN_HAP. +* @tc.type: FUNC +* @tc.require: + */ +HWTEST_F(CloudDataMockTest, GetHapInfo002, TestSize.Level1) +{ + ZLOGI("CloudDataMockTest GetHapInfo002 start"); + DistributedRdb::PredicatesMemo predicates; + predicates.tables_.push_back(TEST_CLOUD_BUNDLE); + std::vector columns; + CloudData::Participants participants; + EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(_)) + .Times(1) + .WillOnce(Return(ATokenTypeEnum::TOKEN_HAP)); + EXPECT_CALL(*accTokenMock, GetHapTokenInfo(_, _)) + .Times(1) + .WillOnce(Return(-1)); + auto [ret, _] = cloudServiceImpl_->AllocResourceAndShare(TEST_CLOUD_STORE, predicates, columns, participants); + EXPECT_EQ(ret, E_ERROR); + ZLOGI("CloudDataMockTest GetHapInfo002 end"); +} } // namespace DistributedDataTest } // namespace OHOS::Test \ No newline at end of file diff --git a/services/distributeddataservice/service/test/object_manager_mock_test.cpp b/services/distributeddataservice/service/test/object_manager_mock_test.cpp index faf7ca79c..e86596028 100644 --- a/services/distributeddataservice/service/test/object_manager_mock_test.cpp +++ b/services/distributeddataservice/service/test/object_manager_mock_test.cpp @@ -15,21 +15,26 @@ #define LOG_TAG "ObjectManagerMockTest" #include +#include #include "device_manager_adapter_mock.h" #include "device_matrix_mock.h" #include "gtest/gtest.h" +#include "mock/access_token_mock.h" #include "mock/account_delegate_mock.h" #include "mock/distributed_file_daemon_manager_mock.h" #include "mock/meta_data_manager_mock.h" #include "object_manager.h" +#include "object_service_impl.h" using namespace OHOS::DistributedObject; using namespace OHOS::DistributedData; using namespace OHOS::Storage::DistributedFile; +using namespace OHOS::Security::AccessToken; using namespace testing::ext; using namespace testing; +using AssetValue = OHOS::CommonType::AssetValue; using DeviceInfo = OHOS::AppDistributedKv::DeviceInfo; using OnComplete = OHOS::DistributedData::MetaDataManager::OnComplete; @@ -54,6 +59,8 @@ public: AccountDelegate::instance_ = nullptr; AccountDelegate::RegisterAccountInstance(accountDelegateMock); } + accTokenMock = std::make_shared(); + BAccessTokenKit::accessTokenkit = accTokenMock; } static void TearDownTestCase(void) { @@ -71,6 +78,8 @@ public: delete accountDelegateMock; accountDelegateMock = nullptr; } + accTokenMock = nullptr; + BAccessTokenKit::accessTokenkit = nullptr; } static inline std::shared_ptr metaDataManagerMock = nullptr; @@ -79,8 +88,14 @@ public: static inline std::shared_ptr deviceMatrixMock = nullptr; static inline std::shared_ptr fileDaemonMgrMock = nullptr; static inline AccountDelegateMock *accountDelegateMock = nullptr; + static inline std::shared_ptr accTokenMock = nullptr; void SetUp() {}; void TearDown() {}; + +protected: + std::string sessionId_ = "123"; + OHOS::ObjectStore::AssetBindInfo assetBindInfo_; + AssetValue assetValue_; }; /** @@ -391,7 +406,7 @@ HWTEST_F(ObjectManagerMockTest, InitUserMeta001, TestSize.Level1) std::vector users; EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(users), Return(false))); auto status = manager.InitUserMeta(); - ASSERT_EQ(status, DistributedObject::OBJECT_INNER_ERROR); + EXPECT_EQ(status, DistributedObject::OBJECT_INNER_ERROR); } /** @@ -410,7 +425,7 @@ HWTEST_F(ObjectManagerMockTest, InitUserMeta002, TestSize.Level1) .WillOnce( DoAll(SetArgReferee<0>(users), Invoke([](std::vector &users) { users.clear(); }), Return(true))); auto status = manager.InitUserMeta(); - ASSERT_EQ(status, DistributedObject::OBJECT_INNER_ERROR); + EXPECT_EQ(status, DistributedObject::OBJECT_INNER_ERROR); } /** @@ -428,7 +443,80 @@ HWTEST_F(ObjectManagerMockTest, InitUserMeta003, TestSize.Level1) std::vector users = { 0, 1 }; EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(users), Return(true))); auto status = manager.InitUserMeta(); - ASSERT_EQ(status, DistributedObject::OBJECT_INNER_ERROR); + EXPECT_EQ(status, DistributedObject::OBJECT_INNER_ERROR); +} + +/** +* @tc.name: BindAsset001 +* @tc.desc: Test BindAsset function when GetTokenTypeFlag is not TOKEN_HAP. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectManagerMockTest, BindAsset001, TestSize.Level1) +{ + auto &manager = ObjectStoreManager::GetInstance(); + std::string bundleName = "BindAsset"; + uint32_t tokenId = IPCSkeleton::GetCallingTokenID(); + EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(_)) + .Times(1) + .WillOnce(Return(ATokenTypeEnum::TOKEN_NATIVE)); + auto result = manager.BindAsset(tokenId, bundleName, sessionId_, assetValue_, assetBindInfo_); + EXPECT_EQ(result, DistributedObject::OBJECT_DBSTATUS_ERROR); +} + +/** +* @tc.name: BindAsset002 +* @tc.desc: Test BindAsset function when GetTokenTypeFlag is TOKEN_HAP. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectManagerMockTest, BindAsset002, TestSize.Level1) +{ + auto &manager = ObjectStoreManager::GetInstance(); + std::string bundleName = "BindAsset"; + uint32_t tokenId = IPCSkeleton::GetCallingTokenID(); + EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(_)) + .Times(1) + .WillOnce(Return(ATokenTypeEnum::TOKEN_HAP)); + EXPECT_CALL(*accTokenMock, GetHapTokenInfo(_, _)) + .Times(1) + .WillOnce(Return(0)); + auto result = manager.BindAsset(tokenId, bundleName, sessionId_, assetValue_, assetBindInfo_); + EXPECT_EQ(result, DistributedObject::OBJECT_SUCCESS); +} + +/** +* @tc.name: IsContinue001 +* @tc.desc: Test IsContinue function when GetTokenTypeFlag is not TOKEN_HAP. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectManagerMockTest, IsContinue001, TestSize.Level1) +{ + std::shared_ptr objectServiceImpl = std::make_shared(); + bool isContinue = false; + EXPECT_CALL(*fileDaemonMgrMock, UnRegisterAssetCallback(_)).WillRepeatedly(testing::Return(0)); + EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(_)) + .Times(1) + .WillOnce(Return(ATokenTypeEnum::TOKEN_NATIVE)); + auto ret = objectServiceImpl->IsContinue(isContinue); + EXPECT_EQ(ret, DistributedObject::OBJECT_INNER_ERROR); +} + +/** +* @tc.name: IsContinue002 +* @tc.desc: Test IsContinue function when GetTokenTypeFlag is TOKEN_HAP. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectManagerMockTest, IsContinue002, TestSize.Level1) +{ + std::shared_ptr objectServiceImpl = std::make_shared(); + bool isContinue = false; + EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(_)) + .Times(2) + .WillRepeatedly(Return(ATokenTypeEnum::TOKEN_HAP)); + EXPECT_CALL(*accTokenMock, GetHapTokenInfo(_, _)) + .Times(1) + .WillOnce(Return(0)); + auto ret = objectServiceImpl->IsContinue(isContinue); + EXPECT_EQ(ret, DistributedObject::OBJECT_SUCCESS); } }; // namespace DistributedDataTest } // namespace OHOS::Test \ No newline at end of file -- Gitee From 32412fe8544de9b938dc073872a91dc452680147 Mon Sep 17 00:00:00 2001 From: gecheng Date: Thu, 7 Aug 2025 17:13:47 +0800 Subject: [PATCH 2/6] =?UTF-8?q?TOKEN=5FHAP=E7=B1=BB=E5=9E=8B=E6=A0=A1?= =?UTF-8?q?=E9=AA=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../test/object_service_impl_mock_test.cpp | 945 ++++++++++++++++++ 1 file changed, 945 insertions(+) create mode 100644 services/distributeddataservice/service/test/object_service_impl_mock_test.cpp diff --git a/services/distributeddataservice/service/test/object_service_impl_mock_test.cpp b/services/distributeddataservice/service/test/object_service_impl_mock_test.cpp new file mode 100644 index 000000000..3bcb06aba --- /dev/null +++ b/services/distributeddataservice/service/test/object_service_impl_mock_test.cpp @@ -0,0 +1,945 @@ +/* +* 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. +*/ + +#define LOG_TAG "ObjectServiceImpMocklTest" +#include +#include + +#include +#include +#include "object_service_impl.h" +#include "mock_dm_adapter.h" +#include "mock_object_store_manager.h" +#include "mock_account_delegate.h" +#include "mock_bootstrap.h" +#include "mock_directory_manager.h" +#include "mock_meta_data_manager.h" +#include "mock_feature.h" +#include "mock_object_dms_handler.h" + +using namespace testing; +using namespace OHOS::DistributedObject; +using namespace OHOS::DistributedData; +using namespace OHOS::Storage::DistributedFile; +using namespace OHOS::Security::AccessToken; +using namespace testing::ext; +using namespace testing; +using AssetValue = OHOS::CommonType::AssetValue; +using DeviceInfo = OHOS::AppDistributedKv::DeviceInfo; +using OnComplete = OHOS::DistributedData::MetaDataManager::OnComplete; +namespace OHOS::Test { +namespace DistributedDataTest { + +class ObjectServiceImpMocklTest : public testing::Test { +public: + static void SetUpTestCase(void) + { + metaDataManagerMock = std::make_shared(); + BMetaDataManager::metaDataManager = metaDataManagerMock; + metaDataMock = std::make_shared>(); + BMetaData::metaDataManager = metaDataMock; + devMgrAdapterMock = std::make_shared(); + BDeviceManagerAdapter::deviceManagerAdapter = devMgrAdapterMock; + deviceMatrixMock = std::make_shared(); + BDeviceMatrix::deviceMatrix = deviceMatrixMock; + fileDaemonMgrMock = std::make_shared(); + BDistributedFileDaemonManager::fileDaemonManger_ = fileDaemonMgrMock; + accountDelegateMock = new (std::nothrow) AccountDelegateMock(); + if (accountDelegateMock != nullptr) { + AccountDelegate::instance_ = nullptr; + AccountDelegate::RegisterAccountInstance(accountDelegateMock); + } + accTokenMock = std::make_shared(); + BAccessTokenKit::accessTokenkit = accTokenMock; + } + static void TearDownTestCase(void) + { + metaDataManagerMock = nullptr; + BMetaDataManager::metaDataManager = nullptr; + metaDataMock = nullptr; + BMetaData::metaDataManager = nullptr; + devMgrAdapterMock = nullptr; + BDeviceManagerAdapter::deviceManagerAdapter = nullptr; + deviceMatrixMock = nullptr; + BDeviceMatrix::deviceMatrix = nullptr; + fileDaemonMgrMock = nullptr; + BDistributedFileDaemonManager::fileDaemonManger_ = nullptr; + if (accountDelegateMock != nullptr) { + delete accountDelegateMock; + accountDelegateMock = nullptr; + } + accTokenMock = nullptr; + BAccessTokenKit::accessTokenkit = nullptr; + } + + static inline std::shared_ptr metaDataManagerMock = nullptr; + static inline std::shared_ptr> metaDataMock = nullptr; + static inline std::shared_ptr devMgrAdapterMock = nullptr; + static inline std::shared_ptr deviceMatrixMock = nullptr; + static inline std::shared_ptr fileDaemonMgrMock = nullptr; + static inline AccountDelegateMock *accountDelegateMock = nullptr; + static inline std::shared_ptr accTokenMock = nullptr; + void SetUp() {}; + void TearDown() {}; + +protected: + std::string sessionId_ = "123"; + OHOS::ObjectStore::AssetBindInfo assetBindInfo_; + AssetValue assetValue_; +}; +// OnInitialize测试 +TEST_F(ObjectServiceImplTest, OnInitialize_LocalDeviceIdEmpty_ReturnsError) +{ + // Given + MockDmAdapter::MockGetLocalDeviceReturnsEmptyUuid(); + + // When + int32_t result = objectServiceImpl->OnInitialize(); + + // Then + EXPECT_EQ(result, OBJECT_INNER_ERROR); +} + +TEST_F(ObjectServiceImplTest, OnInitialize_ExecutorsNull_ReturnsError) +{ + // Given + MockDmAdapter::MockGetLocalDeviceReturnsValidUuid(); + objectServiceImpl->executors_ = nullptr; + + // When + int32_t result = objectServiceImpl->OnInitialize(); + + // Then + EXPECT_EQ(result, OBJECT_INNER_ERROR); +} + +TEST_F(ObjectServiceImplTest, OnInitialize_NormalCase_ReturnsSuccess) +{ + // Given + MockDmAdapter::MockGetLocalDeviceReturnsValidUuid(); + objectServiceImpl->executors_ = std::make_shared(); + EXPECT_CALL(*std::static_pointer_cast(objectServiceImpl->executors_), Schedule(_, _)) + .Times(1); + + // When + int32_t result = objectServiceImpl->OnInitialize(); + + // Then + EXPECT_EQ(result, OBJECT_SUCCESS); +} + +// SaveMetaData测试 +TEST_F(ObjectServiceImplTest, SaveMetaData_LocalDeviceIdEmpty_ReturnsError) +{ + // Given + MockDmAdapter::MockGetLocalDeviceReturnsEmptyUuid(); + StoreMetaData saveMeta; + + // When + int32_t result = objectServiceImpl->SaveMetaData(saveMeta); + + // Then + EXPECT_EQ(result, OBJECT_INNER_ERROR); +} + +TEST_F(ObjectServiceImplTest, SaveMetaData_CreateDirectoryFailed_ReturnsError) +{ + // Given + MockDmAdapter::MockGetLocalDeviceReturnsValidUuid(); + MockBootstrap::MockGetProcessLabelReturnsValidLabel(); + MockAccountDelegate::MockGetCurrentAccountIdReturnsValidId(); + MockAccountDelegate::MockQueryForegroundUserIdReturnsValidId(); + MockDirectoryManager::MockCreateDirectoryReturns(false); + StoreMetaData saveMeta; + + // When + int32_t result = objectServiceImpl->SaveMetaData(saveMeta); + + // Then + EXPECT_EQ(result, OBJECT_INNER_ERROR); +} + +TEST_F(ObjectServiceImplTest, SaveMetaData_SaveMetaFailed_ReturnsError) +{ + // Given + MockDmAdapter::MockGetLocalDeviceReturnsValidUuid(); + MockBootstrap::MockGetProcessLabelReturnsValidLabel(); + MockAccountDelegate::MockGetCurrentAccountIdReturnsValidId(); + MockAccountDelegate::MockQueryForegroundUserIdReturnsValidId(); + MockDirectoryManager::MockCreateDirectoryReturns(true); + MockMetaDataManager::MockSaveMetaReturns(false); + StoreMetaData saveMeta; + + // When + int32_t result = objectServiceImpl->SaveMetaData(saveMeta); + + // Then + EXPECT_EQ(result, OBJECT_INNER_ERROR); +} + +TEST_F(ObjectServiceImplTest, SaveMetaData_NormalCase_ReturnsSuccess) +{ + // Given + MockDmAdapter::MockGetLocalDeviceReturnsValidUuid(); + MockBootstrap::MockGetProcessLabelReturnsValidLabel(); + MockAccountDelegate::MockGetCurrentAccountIdReturnsValidId(); + MockAccountDelegate::MockQueryForegroundUserIdReturnsValidId(); + MockDirectoryManager::MockCreateDirectoryReturns(true); + MockMetaDataManager::MockSaveMetaReturns(true); + StoreMetaData saveMeta; + + // When + int32_t result = objectServiceImpl->SaveMetaData(saveMeta); + + // Then + EXPECT_EQ(result, OBJECT_SUCCESS); +} + +// OnUserChange测试 +TEST_F(ObjectServiceImplTest, OnUserChange_AccountSwitched_ClearFailed_StillCallsParent) +{ + // Given + uint32_t code = static_cast(AccountStatus::DEVICE_ACCOUNT_SWITCHED); + std::string user = "testUser"; + std::string account = "testAccount"; + MockObjectStoreManager::MockClearReturns(OBJECT_INNER_ERROR); + MockDmAdapter::MockGetLocalDeviceReturnsValidUuid(); + MockBootstrap::MockGetProcessLabelReturnsValidLabel(); + MockAccountDelegate::MockGetCurrentAccountIdReturnsValidId(); + MockAccountDelegate::MockQueryForegroundUserIdReturnsValidId(); + MockDirectoryManager::MockCreateDirectoryReturns(true); + MockMetaDataManager::MockSaveMetaReturns(true); + MockFeature::MockOnUserChangeReturns(OBJECT_SUCCESS); + + // When + int32_t result = objectServiceImpl->OnUserChange(code, user, account); + + // Then + EXPECT_EQ(result, OBJECT_SUCCESS); +} + +TEST_F(ObjectServiceImplTest, OnUserChange_NotAccountSwitched_OnlyCallsParent) +{ + // Given + uint32_t code = 0; // 不是账户切换 + std::string user = "testUser"; + std::string account = "testAccount"; + MockFeature::MockOnUserChangeReturns(OBJECT_SUCCESS); + + // When + int32_t result = objectServiceImpl->OnUserChange(code, user, account); + + // Then + EXPECT_EQ(result, OBJECT_SUCCESS); +} + +// ObjectStoreRevokeSave测试 +TEST_F(ObjectServiceImplTest, ObjectStoreRevokeSave_BundleNameCheckFailed_ReturnsError) +{ + // Given + std::string bundleName = "testBundle"; + std::string sessionId = "testSession"; + sptr callback = nullptr; + MockIPCSkeleton::MockGetCallingTokenIDReturns(123); + // 假设IsBundleNameEqualTokenId会失败 + MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_INNER_ERROR); + + // When + int32_t result = objectServiceImpl->ObjectStoreRevokeSave(bundleName, sessionId, callback); + + // Then + EXPECT_EQ(result, OBJECT_INNER_ERROR); +} + +TEST_F(ObjectServiceImplTest, ObjectStoreRevokeSave_RevokeSaveFailed_ReturnsError) +{ + // Given + std::string bundleName = "testBundle"; + std::string sessionId = "testSession"; + sptr callback = nullptr; + MockIPCSkeleton::MockGetCallingTokenIDReturns(123); + MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_SUCCESS); + MockObjectStoreManager::MockRevokeSaveReturns(OBJECT_INNER_ERROR); + + // When + int32_t result = objectServiceImpl->ObjectStoreRevokeSave(bundleName, sessionId, callback); + + // Then + EXPECT_EQ(result, OBJECT_INNER_ERROR); +} + +TEST_F(ObjectServiceImplTest, ObjectStoreRevokeSave_NormalCase_ReturnsSuccess) +{ + // Given + std::string bundleName = "testBundle"; + std::string sessionId = "testSession"; + sptr callback = nullptr; + MockIPCSkeleton::MockGetCallingTokenIDReturns(123); + MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_SUCCESS); + MockObjectStoreManager::MockRevokeSaveReturns(OBJECT_SUCCESS); + + // When + int32_t result = objectServiceImpl->ObjectStoreRevokeSave(bundleName, sessionId, callback); + + // Then + EXPECT_EQ(result, OBJECT_SUCCESS); +} + +// ObjectStoreRetrieve测试 +TEST_F(ObjectServiceImplTest, ObjectStoreRetrieve_BundleNameCheckFailed_ReturnsError) +{ + // Given + std::string bundleName = "testBundle"; + std::string sessionId = "testSession"; + sptr callback = nullptr; + MockIPCSkeleton::MockGetCallingTokenIDReturns(123); + MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_INNER_ERROR); + + // When + int32_t result = objectServiceImpl->ObjectStoreRetrieve(bundleName, sessionId, callback); + + // Then + EXPECT_EQ(result, OBJECT_INNER_ERROR); +} + +TEST_F(ObjectServiceImplTest, ObjectStoreRetrieve_RetrieveFailed_ReturnsError) +{ + // Given + std::string bundleName = "testBundle"; + std::string sessionId = "testSession"; + sptr callback = nullptr; + MockIPCSkeleton::MockGetCallingTokenIDReturns(123); + MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_SUCCESS); + MockObjectStoreManager::MockRetrieveReturns(OBJECT_INNER_ERROR); + + // When + int32_t result = objectServiceImpl->ObjectStoreRetrieve(bundleName, sessionId, callback); + + // Then + EXPECT_EQ(result, OBJECT_INNER_ERROR); +} + +TEST_F(ObjectServiceImplTest, ObjectStoreRetrieve_NormalCase_ReturnsSuccess) +{ + // Given + std::string bundleName = "testBundle"; + std::string sessionId = "testSession"; + sptr callback = nullptr; + MockIPCSkeleton::MockGetCallingTokenIDReturns(123); + MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_SUCCESS); + MockObjectStoreManager::MockRetrieveReturns(OBJECT_SUCCESS); + + // When + int32_t result = objectServiceImpl->ObjectStoreRetrieve(bundleName, sessionId, callback); + + // Then + EXPECT_EQ(result, OBJECT_SUCCESS); +} + +// RegisterDataObserver测试 +TEST_F(ObjectServiceImplTest, RegisterDataObserver_BundleNameCheckFailed_ReturnsError) +{ + // Given + std::string bundleName = "testBundle"; + std::string sessionId = "testSession"; + sptr callback = nullptr; + MockIPCSkeleton::MockGetCallingTokenIDReturns(123); + MockIPCSkeleton::MockGetCallingPidReturns(456); + MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_INNER_ERROR); + + // When + int32_t result = objectServiceImpl->RegisterDataObserver(bundleName, sessionId, callback); + + // Then + EXPECT_EQ(result, OBJECT_INNER_ERROR); +} + +TEST_F(ObjectServiceImplTest, RegisterDataObserver_NormalCase_ReturnsSuccess) +{ + // Given + std::string bundleName = "testBundle"; + std::string sessionId = "testSession"; + sptr callback = nullptr; + MockIPCSkeleton::MockGetCallingTokenIDReturns(123); + MockIPCSkeleton::MockGetCallingPidReturns(456); + MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_SUCCESS); + MockObjectStoreManager::MockRegisterRemoteCallbackReturns(); + + // When + int32_t result = objectServiceImpl->RegisterDataObserver(bundleName, sessionId, callback); + + // Then + EXPECT_EQ(result, OBJECT_SUCCESS); +} + +// UnregisterDataChangeObserver测试 +TEST_F(ObjectServiceImplTest, UnregisterDataChangeObserver_BundleNameCheckFailed_ReturnsError) +{ + // Given + std::string bundleName = "testBundle"; + std::string sessionId = "testSession"; + MockIPCSkeleton::MockGetCallingTokenIDReturns(123); + MockIPCSkeleton::MockGetCallingPidReturns(456); + MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_INNER_ERROR); + + // When + int32_t result = objectServiceImpl->UnregisterDataChangeObserver(bundleName, sessionId); + + // Then + EXPECT_EQ(result, OBJECT_INNER_ERROR); +} + +TEST_F(ObjectServiceImplTest, UnregisterDataChangeObserver_NormalCase_ReturnsSuccess) +{ + // Given + std::string bundleName = "testBundle"; + std::string sessionId = "testSession"; + MockIPCSkeleton::MockGetCallingTokenIDReturns(123); + MockIPCSkeleton::MockGetCallingPidReturns(456); + MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_SUCCESS); + MockObjectStoreManager::MockUnregisterRemoteCallbackReturns(); + + // When + int32_t result = objectServiceImpl->UnregisterDataChangeObserver(bundleName, sessionId); + + // Then + EXPECT_EQ(result, OBJECT_SUCCESS); +} + +// RegisterProgressObserver测试 +TEST_F(ObjectServiceImplTest, RegisterProgressObserver_BundleNameCheckFailed_ReturnsError) +{ + // Given + std::string bundleName = "testBundle"; + std::string sessionId = "testSession"; + sptr callback = nullptr; + MockIPCSkeleton::MockGetCallingTokenIDReturns(123); + MockIPCSkeleton::MockGetCallingPidReturns(456); + MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_INNER_ERROR); + + // When + int32_t result = objectServiceImpl->RegisterProgressObserver(bundleName, sessionId, callback); + + // Then + EXPECT_EQ(result, OBJECT_INNER_ERROR); +} + +TEST_F(ObjectServiceImplTest, RegisterProgressObserver_NormalCase_ReturnsSuccess) +{ + // Given + std::string bundleName = "testBundle"; + std::string sessionId = "testSession"; + sptr callback = nullptr; + MockIPCSkeleton::MockGetCallingTokenIDReturns(123); + MockIPCSkeleton::MockGetCallingPidReturns(456); + MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_SUCCESS); + MockObjectStoreManager::MockRegisterProgressObserverCallbackReturns(); + + // When + int32_t result = objectServiceImpl->RegisterProgressObserver(bundleName, sessionId, callback); + + // Then + EXPECT_EQ(result, OBJECT_SUCCESS); +} + +// UnregisterProgressObserver测试 +TEST_F(ObjectServiceImplTest, UnregisterProgressObserver_BundleNameCheckFailed_ReturnsError) +{ + // Given + std::string bundleName = "testBundle"; + std::string sessionId = "testSession"; + MockIPCSkeleton::MockGetCallingTokenIDReturns(123); + MockIPCSkeleton::MockGetCallingPidReturns(456); + MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_INNER_ERROR); + + // When + int32_t result = objectServiceImpl->UnregisterProgressObserver(bundleName, sessionId); + + // Then + EXPECT_EQ(result, OBJECT_INNER_ERROR); +} + +TEST_F(ObjectServiceImplTest, UnregisterProgressObserver_NormalCase_ReturnsSuccess) +{ + // Given + std::string bundleName = "testBundle"; + std::string sessionId = "testSession"; + MockIPCSkeleton::MockGetCallingTokenIDReturns(123); + MockIPCSkeleton::MockGetCallingPidReturns(456); + MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_SUCCESS); + MockObjectStoreManager::MockUnregisterProgressObserverCallbackReturns(); + + // When + int32_t result = objectServiceImpl->UnregisterProgressObserver(bundleName, sessionId); + + // Then + EXPECT_EQ(result, OBJECT_SUCCESS); +} + +// DeleteSnapshot测试 +TEST_F(ObjectServiceImplTest, DeleteSnapshot_BundleNameCheckFailed_ReturnsError) +{ + // Given + std::string bundleName = "testBundle"; + std::string sessionId = "testSession"; + MockIPCSkeleton::MockGetCallingTokenIDReturns(123); + MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_INNER_ERROR); + + // When + int32_t result = objectServiceImpl->DeleteSnapshot(bundleName, sessionId); + + // Then + EXPECT_EQ(result, OBJECT_INNER_ERROR); +} + +TEST_F(ObjectServiceImplTest, DeleteSnapshot_NormalCase_ReturnsSuccess) +{ + // Given + std::string bundleName = "testBundle"; + std::string sessionId = "testSession"; + MockIPCSkeleton::MockGetCallingTokenIDReturns(123); + MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_SUCCESS); + MockObjectStoreManager::MockDeleteSnapshotReturns(); + + // When + int32_t result = objectServiceImpl->DeleteSnapshot(bundleName, sessionId); + + // Then + EXPECT_EQ(result, OBJECT_SUCCESS); +} + + +/** + * @tc.name: IsNeedMetaSync001 + * @tc.desc: Test IsNeedMetaSync when LoadMeta fails for CapMetaData. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(ObjectServiceImpMocklTest, IsNeedMetaSync001, TestSize.Level0) +{ + EXPECT_CALL(*fileDaemonMgrMock, RegisterAssetCallback(_)).WillOnce(testing::Return(0)); + auto &manager = ObjectStoreManager::GetInstance(); + StoreMetaData meta; + meta.deviceId = "test_device_id"; + meta.user = "0"; + meta.storeId = "distributedObject_"; + meta.bundleName = "test_bundle"; + std::vector uuids = { "test_uuid" }; + + EXPECT_CALL(*metaDataManagerMock, LoadMeta(testing::_, testing::_, testing::_)).WillOnce(testing::Return(false)); + bool isNeedSync = manager.IsNeedMetaSync(meta, uuids); + EXPECT_EQ(isNeedSync, true); + EXPECT_CALL(*metaDataManagerMock, LoadMeta(testing::_, testing::_, testing::_)) + .WillOnce(testing::Return(true)) + .WillOnce(testing::Return(false)); + isNeedSync = manager.IsNeedMetaSync(meta, uuids); + EXPECT_EQ(isNeedSync, true); +} + +/** + * @tc.name: IsNeedMetaSync002 + * @tc.desc: Test IsNeedMetaSync when LoadMeta fails for StoreMetaData. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(ObjectServiceImpMocklTest, IsNeedMetaSync002, TestSize.Level0) +{ + auto &manager = ObjectStoreManager::GetInstance(); + StoreMetaData meta; + meta.deviceId = "test_device_id"; + meta.user = "0"; + meta.storeId = "distributedObject_"; + meta.bundleName = "test_bundle"; + std::vector uuids = { "test_uuid" }; + + EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)).WillRepeatedly(Return((true))); + EXPECT_CALL(*deviceMatrixMock, GetRemoteMask(_, _)) + .WillRepeatedly(Return(std::make_pair(true, DeviceMatrix::META_STORE_MASK))); + + bool result = manager.IsNeedMetaSync(meta, uuids); + EXPECT_EQ(result, true); +} + +/** + * @tc.name: IsNeedMetaSync003 + * @tc.desc: Test IsNeedMetaSync when LoadMeta fails for StoreMetaData. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(ObjectServiceImpMocklTest, IsNeedMetaSync003, TestSize.Level0) +{ + auto &manager = ObjectStoreManager::GetInstance(); + StoreMetaData meta; + meta.deviceId = "test_device_id"; + meta.user = "0"; + meta.storeId = "distributedObject_"; + meta.bundleName = "test_bundle"; + std::vector uuids = { "test_uuid" }; + + EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)).WillRepeatedly(Return(true)); + EXPECT_CALL(*deviceMatrixMock, GetRemoteMask(_, _)).WillOnce(Return(std::make_pair(true, 0))); + EXPECT_CALL(*deviceMatrixMock, GetMask(_, _)).WillOnce(Return(std::make_pair(true, DeviceMatrix::META_STORE_MASK))); + + bool result = manager.IsNeedMetaSync(meta, uuids); + EXPECT_EQ(result, true); + + EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)).WillRepeatedly(Return(true)); + + EXPECT_CALL(*deviceMatrixMock, GetRemoteMask(_, _)).WillOnce(Return(std::make_pair(true, 0))); + + EXPECT_CALL(*deviceMatrixMock, GetMask(_, _)).WillOnce(Return(std::make_pair(true, 0))); + + result = manager.IsNeedMetaSync(meta, uuids); + EXPECT_EQ(result, false); +} + +/** + * @tc.name: SyncOnStore001 + * @tc.desc: Test SyncOnStore. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(ObjectServiceImpMocklTest, SyncOnStore001, TestSize.Level0) +{ + // 2 means that the GetUserByToken interface will be called twice + EXPECT_CALL(*accountDelegateMock, GetUserByToken(_)).Times(2).WillRepeatedly(Return(0)); + auto &manager = ObjectStoreManager::GetInstance(); + std::function &results)> func; + func = [](const std::map &results) { return results; }; + std::string prefix = "ObjectManagerTest"; + StoreMetaData meta; + meta.deviceId = "test_device_id"; + meta.user = "0"; + meta.storeId = "distributedObject_"; + meta.bundleName = "test_bundle"; + std::vector uuids = { "test_uuid" }; + + // local device + { + std::vector localDeviceList = { "local" }; + auto result = manager.SyncOnStore(prefix, localDeviceList, func); + EXPECT_EQ(result, OBJECT_SUCCESS); + } + + // remote device. IsNeedMetaSync: true; Sync: true + { + std::vector remoteDeviceList = { "remote_device_1" }; + EXPECT_CALL(*devMgrAdapterMock, GetUuidByNetworkId(_)).WillRepeatedly(Return("mock_uuid")); + EXPECT_CALL(*devMgrAdapterMock, ToUUID(testing::A &>())) + .WillOnce(Return(std::vector{ "mock_uuid_1" })); + EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)).WillOnce(testing::Return(false)); + EXPECT_CALL(*metaDataManagerMock, Sync(_, _, _)).WillOnce(testing::Return(true)); + auto result = manager.SyncOnStore(prefix, remoteDeviceList, func); + EXPECT_EQ(result, OBJECT_SUCCESS); + } + + // remote device. IsNeedMetaSync: false + { + std::vector remoteDeviceList = { "remote_device_1" }; + EXPECT_CALL(*devMgrAdapterMock, GetUuidByNetworkId(_)).WillRepeatedly(Return("mock_uuid")); + EXPECT_CALL(*devMgrAdapterMock, ToUUID(testing::A &>())) + .WillOnce(Return(std::vector{ "mock_uuid_1" })); + EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)) + .WillOnce(testing::Return(true)) + .WillOnce(testing::Return(true)); + EXPECT_CALL(*deviceMatrixMock, GetRemoteMask(_, _)).WillOnce(Return(std::make_pair(true, 0))); + EXPECT_CALL(*deviceMatrixMock, GetMask(_, _)).WillOnce(Return(std::make_pair(true, 0))); + auto result = manager.SyncOnStore(prefix, remoteDeviceList, func); + EXPECT_EQ(result, E_DB_ERROR); + } +} + +/** +* @tc.name: GetCurrentUser001 +* @tc.desc: Test the scenario where the QueryUsers return false in the GetCurrentUser function. +* @tc.type: FUNC +* @tc.require: +* @tc.author: +*/ +HWTEST_F(ObjectServiceImpMocklTest, GetCurrentUser001, TestSize.Level1) +{ + auto &manager = ObjectStoreManager::GetInstance(); + std::vector users; + EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(users), Return(false))); + auto result = manager.GetCurrentUser(); + EXPECT_EQ(result, ""); +} + +/** +* @tc.name: GetCurrentUser002 +* @tc.desc: Test the scenario where the QueryUsers users empty in the GetCurrentUser function. +* @tc.type: FUNC +* @tc.require: +* @tc.author: +*/ +HWTEST_F(ObjectServiceImpMocklTest, GetCurrentUser002, TestSize.Level1) +{ + auto &manager = ObjectStoreManager::GetInstance(); + std::vector users; + EXPECT_CALL(*accountDelegateMock, QueryUsers(_)) + .Times(1) + .WillOnce( + DoAll(SetArgReferee<0>(users), Invoke([](std::vector &users) { users.clear(); }), Return(true))); + auto result = manager.GetCurrentUser(); + EXPECT_EQ(result, ""); +} + +/** +* @tc.name: GetCurrentUser003 +* @tc.desc: Test the scenario where the QueryUsers return true in the GetCurrentUser function. +* @tc.type: FUNC +* @tc.require: +* @tc.author: +*/ +HWTEST_F(ObjectServiceImpMocklTest, GetCurrentUser003, TestSize.Level1) +{ + auto &manager = ObjectStoreManager::GetInstance(); + std::vector users = { 0, 1 }; + EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(users), Return(true))); + auto result = manager.GetCurrentUser(); + EXPECT_EQ(result, std::to_string(users[0])); +} + +/** +* @tc.name: WaitAssets001 +* @tc.desc: WaitAssets test. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectServiceImpMocklTest, WaitAssets001, TestSize.Level1) +{ + auto &manager = ObjectStoreManager::GetInstance(); + std::string objectKey = "objectKey"; + ObjectStoreManager::SaveInfo info; + std::map data; + auto ret = manager.WaitAssets(objectKey, info, data); + EXPECT_EQ(ret, DistributedObject::OBJECT_INNER_ERROR); +} + +/** +* @tc.name: NotifyAssetsReady001 +* @tc.desc: NotifyAssetsReady test. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectServiceImpMocklTest, NotifyAssetsReady001, TestSize.Level1) +{ + auto &manager = ObjectStoreManager::GetInstance(); + std::string objectKey = "objectKey"; + std::string bundleName = "bundleName"; + std::string srcNetworkId = "srcNetworkId"; + manager.NotifyAssetsReady(objectKey, bundleName, srcNetworkId); + EXPECT_EQ(manager.executors_, nullptr); +} + +/** +* @tc.name: DoNotifyAssetsReady001 +* @tc.desc: DoNotifyAssetsReady test. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectServiceImpMocklTest, DoNotifyAssetsReady001, TestSize.Level1) +{ + auto &manager = ObjectStoreManager::GetInstance(); + uint32_t tokenId = 0; + ObjectStoreManager::CallbackInfo info; + std::string objectKey = "objectKey"; + bool isReady = true; + manager.DoNotifyAssetsReady(tokenId, info, objectKey, isReady); + EXPECT_EQ(manager.executors_, nullptr); +} + +/** +* @tc.name: DoNotifyWaitAssetTimeout001 +* @tc.desc: DoNotifyWaitAssetTimeout test. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectServiceImpMocklTest, DoNotifyWaitAssetTimeout001, TestSize.Level1) +{ + auto &manager = ObjectStoreManager::GetInstance(); + std::string objectKey = "objectKey"; + manager.DoNotifyWaitAssetTimeout(objectKey); + EXPECT_EQ(manager.executors_, nullptr); +} + +/** +* @tc.name: FlushClosedStore001 +* @tc.desc: FlushClosedStore test. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectServiceImpMocklTest, FlushClosedStore001, TestSize.Level1) +{ + auto &manager = ObjectStoreManager::GetInstance(); + manager.FlushClosedStore(); + EXPECT_EQ(manager.executors_, nullptr); +} + +/** +* @tc.name: CloseAfterMinute001 +* @tc.desc: CloseAfterMinute test. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectServiceImpMocklTest, CloseAfterMinute001, TestSize.Level1) +{ + auto &manager = ObjectStoreManager::GetInstance(); + manager.CloseAfterMinute(); + EXPECT_EQ(manager.executors_, nullptr); +} + +/** +* @tc.name: UnRegisterAssetsLister001 +* @tc.desc: UnRegisterAssetsLister test. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectServiceImpMocklTest, UnRegisterAssetsLister001, TestSize.Level1) +{ + auto &manager = ObjectStoreManager::GetInstance(); + manager.objectAssetsRecvListener_ = nullptr; + auto ret = manager.UnRegisterAssetsLister(); + EXPECT_EQ(ret, true); + EXPECT_CALL(*fileDaemonMgrMock, RegisterAssetCallback(_)).WillOnce(testing::Return(0)); + manager.RegisterAssetsLister(); + EXPECT_CALL(*fileDaemonMgrMock, UnRegisterAssetCallback(_)).WillOnce(testing::Return(-1)); + ret = manager.UnRegisterAssetsLister(); + EXPECT_EQ(ret, false); + EXPECT_CALL(*fileDaemonMgrMock, UnRegisterAssetCallback(_)).WillOnce(testing::Return(0)); + ret = manager.UnRegisterAssetsLister(); + EXPECT_EQ(ret, true); +} + +/** +* @tc.name: InitUserMeta001 +* @tc.desc: Test the scenario where the QueryUsers return false in the GetCurrentUser function. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectServiceImpMocklTest, InitUserMeta001, TestSize.Level1) +{ + EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)) + .WillOnce(testing::Return(false)); + auto &manager = ObjectStoreManager::GetInstance(); + std::vector users; + EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(users), Return(false))); + auto status = manager.InitUserMeta(); + EXPECT_EQ(status, DistributedObject::OBJECT_INNER_ERROR); +} + +/** +* @tc.name: InitUserMeta002 +* @tc.desc: Test the scenario where the QueryUsers users empty in the GetCurrentUser function. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectServiceImpMocklTest, InitUserMeta002, TestSize.Level1) +{ + EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)) + .WillOnce(testing::Return(false)); + auto &manager = ObjectStoreManager::GetInstance(); + std::vector users; + EXPECT_CALL(*accountDelegateMock, QueryUsers(_)) + .Times(1) + .WillOnce( + DoAll(SetArgReferee<0>(users), Invoke([](std::vector &users) { users.clear(); }), Return(true))); + auto status = manager.InitUserMeta(); + EXPECT_EQ(status, DistributedObject::OBJECT_INNER_ERROR); +} + +/** +* @tc.name: InitUserMeta003 +* @tc.desc: Test the scenario where the QueryUsers return true in the GetCurrentUser function. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectServiceImpMocklTest, InitUserMeta003, TestSize.Level1) +{ + EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)) + .WillOnce(testing::Return(false)); + DeviceInfo devInfo = { .uuid = "666" }; + EXPECT_CALL(*devMgrAdapterMock, GetLocalDevice()).WillOnce(Return(devInfo)); + auto &manager = ObjectStoreManager::GetInstance(); + std::vector users = { 0, 1 }; + EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(users), Return(true))); + auto status = manager.InitUserMeta(); + EXPECT_EQ(status, DistributedObject::OBJECT_INNER_ERROR); +} + +/** +* @tc.name: BindAsset001 +* @tc.desc: Test BindAsset function when GetTokenTypeFlag is not TOKEN_HAP. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectServiceImpMocklTest, BindAsset001, TestSize.Level1) +{ + auto &manager = ObjectStoreManager::GetInstance(); + std::string bundleName = "BindAsset"; + uint32_t tokenId = IPCSkeleton::GetCallingTokenID(); + EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(_)) + .Times(1) + .WillOnce(Return(ATokenTypeEnum::TOKEN_NATIVE)); + auto result = manager.BindAsset(tokenId, bundleName, sessionId_, assetValue_, assetBindInfo_); + EXPECT_EQ(result, DistributedObject::OBJECT_DBSTATUS_ERROR); +} + +/** +* @tc.name: BindAsset002 +* @tc.desc: Test BindAsset function when GetTokenTypeFlag is TOKEN_HAP. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectServiceImpMocklTest, BindAsset002, TestSize.Level1) +{ + auto &manager = ObjectStoreManager::GetInstance(); + std::string bundleName = "BindAsset"; + uint32_t tokenId = IPCSkeleton::GetCallingTokenID(); + EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(_)) + .Times(1) + .WillOnce(Return(ATokenTypeEnum::TOKEN_HAP)); + EXPECT_CALL(*accTokenMock, GetHapTokenInfo(_, _)) + .Times(1) + .WillOnce(Return(0)); + auto result = manager.BindAsset(tokenId, bundleName, sessionId_, assetValue_, assetBindInfo_); + EXPECT_EQ(result, DistributedObject::OBJECT_SUCCESS); +} + +/** +* @tc.name: IsContinue001 +* @tc.desc: Test IsContinue function when GetTokenTypeFlag is not TOKEN_HAP. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectServiceImpMocklTest, IsContinue001, TestSize.Level1) +{ + std::shared_ptr objectServiceImpl = std::make_shared(); + bool isContinue = false; + EXPECT_CALL(*fileDaemonMgrMock, UnRegisterAssetCallback(_)).WillRepeatedly(testing::Return(0)); + EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(_)) + .Times(1) + .WillOnce(Return(ATokenTypeEnum::TOKEN_NATIVE)); + auto ret = objectServiceImpl->IsContinue(isContinue); + EXPECT_EQ(ret, DistributedObject::OBJECT_INNER_ERROR); +} + +/** +* @tc.name: IsContinue002 +* @tc.desc: Test IsContinue function when GetTokenTypeFlag is TOKEN_HAP. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectServiceImpMocklTest, IsContinue002, TestSize.Level1) +{ + std::shared_ptr objectServiceImpl = std::make_shared(); + bool isContinue = false; + EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(_)) + .Times(2) + .WillRepeatedly(Return(ATokenTypeEnum::TOKEN_HAP)); + EXPECT_CALL(*accTokenMock, GetHapTokenInfo(_, _)) + .Times(1) + .WillOnce(Return(0)); + auto ret = objectServiceImpl->IsContinue(isContinue); + EXPECT_EQ(ret, DistributedObject::OBJECT_SUCCESS); +} +}; // namespace DistributedDataTest +} // namespace OHOS::Test \ No newline at end of file -- Gitee From b3fea9e92e13064a552288a83a17e3fa880d2f4d Mon Sep 17 00:00:00 2001 From: gecheng Date: Thu, 7 Aug 2025 17:14:33 +0800 Subject: [PATCH 3/6] =?UTF-8?q?TOKEN=5FHAP=E7=B1=BB=E5=9E=8B=E6=A0=A1?= =?UTF-8?q?=E9=AA=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../test/object_service_impl_mock_test.cpp | 945 ------------------ 1 file changed, 945 deletions(-) delete mode 100644 services/distributeddataservice/service/test/object_service_impl_mock_test.cpp diff --git a/services/distributeddataservice/service/test/object_service_impl_mock_test.cpp b/services/distributeddataservice/service/test/object_service_impl_mock_test.cpp deleted file mode 100644 index 3bcb06aba..000000000 --- a/services/distributeddataservice/service/test/object_service_impl_mock_test.cpp +++ /dev/null @@ -1,945 +0,0 @@ -/* -* 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. -*/ - -#define LOG_TAG "ObjectServiceImpMocklTest" -#include -#include - -#include -#include -#include "object_service_impl.h" -#include "mock_dm_adapter.h" -#include "mock_object_store_manager.h" -#include "mock_account_delegate.h" -#include "mock_bootstrap.h" -#include "mock_directory_manager.h" -#include "mock_meta_data_manager.h" -#include "mock_feature.h" -#include "mock_object_dms_handler.h" - -using namespace testing; -using namespace OHOS::DistributedObject; -using namespace OHOS::DistributedData; -using namespace OHOS::Storage::DistributedFile; -using namespace OHOS::Security::AccessToken; -using namespace testing::ext; -using namespace testing; -using AssetValue = OHOS::CommonType::AssetValue; -using DeviceInfo = OHOS::AppDistributedKv::DeviceInfo; -using OnComplete = OHOS::DistributedData::MetaDataManager::OnComplete; -namespace OHOS::Test { -namespace DistributedDataTest { - -class ObjectServiceImpMocklTest : public testing::Test { -public: - static void SetUpTestCase(void) - { - metaDataManagerMock = std::make_shared(); - BMetaDataManager::metaDataManager = metaDataManagerMock; - metaDataMock = std::make_shared>(); - BMetaData::metaDataManager = metaDataMock; - devMgrAdapterMock = std::make_shared(); - BDeviceManagerAdapter::deviceManagerAdapter = devMgrAdapterMock; - deviceMatrixMock = std::make_shared(); - BDeviceMatrix::deviceMatrix = deviceMatrixMock; - fileDaemonMgrMock = std::make_shared(); - BDistributedFileDaemonManager::fileDaemonManger_ = fileDaemonMgrMock; - accountDelegateMock = new (std::nothrow) AccountDelegateMock(); - if (accountDelegateMock != nullptr) { - AccountDelegate::instance_ = nullptr; - AccountDelegate::RegisterAccountInstance(accountDelegateMock); - } - accTokenMock = std::make_shared(); - BAccessTokenKit::accessTokenkit = accTokenMock; - } - static void TearDownTestCase(void) - { - metaDataManagerMock = nullptr; - BMetaDataManager::metaDataManager = nullptr; - metaDataMock = nullptr; - BMetaData::metaDataManager = nullptr; - devMgrAdapterMock = nullptr; - BDeviceManagerAdapter::deviceManagerAdapter = nullptr; - deviceMatrixMock = nullptr; - BDeviceMatrix::deviceMatrix = nullptr; - fileDaemonMgrMock = nullptr; - BDistributedFileDaemonManager::fileDaemonManger_ = nullptr; - if (accountDelegateMock != nullptr) { - delete accountDelegateMock; - accountDelegateMock = nullptr; - } - accTokenMock = nullptr; - BAccessTokenKit::accessTokenkit = nullptr; - } - - static inline std::shared_ptr metaDataManagerMock = nullptr; - static inline std::shared_ptr> metaDataMock = nullptr; - static inline std::shared_ptr devMgrAdapterMock = nullptr; - static inline std::shared_ptr deviceMatrixMock = nullptr; - static inline std::shared_ptr fileDaemonMgrMock = nullptr; - static inline AccountDelegateMock *accountDelegateMock = nullptr; - static inline std::shared_ptr accTokenMock = nullptr; - void SetUp() {}; - void TearDown() {}; - -protected: - std::string sessionId_ = "123"; - OHOS::ObjectStore::AssetBindInfo assetBindInfo_; - AssetValue assetValue_; -}; -// OnInitialize测试 -TEST_F(ObjectServiceImplTest, OnInitialize_LocalDeviceIdEmpty_ReturnsError) -{ - // Given - MockDmAdapter::MockGetLocalDeviceReturnsEmptyUuid(); - - // When - int32_t result = objectServiceImpl->OnInitialize(); - - // Then - EXPECT_EQ(result, OBJECT_INNER_ERROR); -} - -TEST_F(ObjectServiceImplTest, OnInitialize_ExecutorsNull_ReturnsError) -{ - // Given - MockDmAdapter::MockGetLocalDeviceReturnsValidUuid(); - objectServiceImpl->executors_ = nullptr; - - // When - int32_t result = objectServiceImpl->OnInitialize(); - - // Then - EXPECT_EQ(result, OBJECT_INNER_ERROR); -} - -TEST_F(ObjectServiceImplTest, OnInitialize_NormalCase_ReturnsSuccess) -{ - // Given - MockDmAdapter::MockGetLocalDeviceReturnsValidUuid(); - objectServiceImpl->executors_ = std::make_shared(); - EXPECT_CALL(*std::static_pointer_cast(objectServiceImpl->executors_), Schedule(_, _)) - .Times(1); - - // When - int32_t result = objectServiceImpl->OnInitialize(); - - // Then - EXPECT_EQ(result, OBJECT_SUCCESS); -} - -// SaveMetaData测试 -TEST_F(ObjectServiceImplTest, SaveMetaData_LocalDeviceIdEmpty_ReturnsError) -{ - // Given - MockDmAdapter::MockGetLocalDeviceReturnsEmptyUuid(); - StoreMetaData saveMeta; - - // When - int32_t result = objectServiceImpl->SaveMetaData(saveMeta); - - // Then - EXPECT_EQ(result, OBJECT_INNER_ERROR); -} - -TEST_F(ObjectServiceImplTest, SaveMetaData_CreateDirectoryFailed_ReturnsError) -{ - // Given - MockDmAdapter::MockGetLocalDeviceReturnsValidUuid(); - MockBootstrap::MockGetProcessLabelReturnsValidLabel(); - MockAccountDelegate::MockGetCurrentAccountIdReturnsValidId(); - MockAccountDelegate::MockQueryForegroundUserIdReturnsValidId(); - MockDirectoryManager::MockCreateDirectoryReturns(false); - StoreMetaData saveMeta; - - // When - int32_t result = objectServiceImpl->SaveMetaData(saveMeta); - - // Then - EXPECT_EQ(result, OBJECT_INNER_ERROR); -} - -TEST_F(ObjectServiceImplTest, SaveMetaData_SaveMetaFailed_ReturnsError) -{ - // Given - MockDmAdapter::MockGetLocalDeviceReturnsValidUuid(); - MockBootstrap::MockGetProcessLabelReturnsValidLabel(); - MockAccountDelegate::MockGetCurrentAccountIdReturnsValidId(); - MockAccountDelegate::MockQueryForegroundUserIdReturnsValidId(); - MockDirectoryManager::MockCreateDirectoryReturns(true); - MockMetaDataManager::MockSaveMetaReturns(false); - StoreMetaData saveMeta; - - // When - int32_t result = objectServiceImpl->SaveMetaData(saveMeta); - - // Then - EXPECT_EQ(result, OBJECT_INNER_ERROR); -} - -TEST_F(ObjectServiceImplTest, SaveMetaData_NormalCase_ReturnsSuccess) -{ - // Given - MockDmAdapter::MockGetLocalDeviceReturnsValidUuid(); - MockBootstrap::MockGetProcessLabelReturnsValidLabel(); - MockAccountDelegate::MockGetCurrentAccountIdReturnsValidId(); - MockAccountDelegate::MockQueryForegroundUserIdReturnsValidId(); - MockDirectoryManager::MockCreateDirectoryReturns(true); - MockMetaDataManager::MockSaveMetaReturns(true); - StoreMetaData saveMeta; - - // When - int32_t result = objectServiceImpl->SaveMetaData(saveMeta); - - // Then - EXPECT_EQ(result, OBJECT_SUCCESS); -} - -// OnUserChange测试 -TEST_F(ObjectServiceImplTest, OnUserChange_AccountSwitched_ClearFailed_StillCallsParent) -{ - // Given - uint32_t code = static_cast(AccountStatus::DEVICE_ACCOUNT_SWITCHED); - std::string user = "testUser"; - std::string account = "testAccount"; - MockObjectStoreManager::MockClearReturns(OBJECT_INNER_ERROR); - MockDmAdapter::MockGetLocalDeviceReturnsValidUuid(); - MockBootstrap::MockGetProcessLabelReturnsValidLabel(); - MockAccountDelegate::MockGetCurrentAccountIdReturnsValidId(); - MockAccountDelegate::MockQueryForegroundUserIdReturnsValidId(); - MockDirectoryManager::MockCreateDirectoryReturns(true); - MockMetaDataManager::MockSaveMetaReturns(true); - MockFeature::MockOnUserChangeReturns(OBJECT_SUCCESS); - - // When - int32_t result = objectServiceImpl->OnUserChange(code, user, account); - - // Then - EXPECT_EQ(result, OBJECT_SUCCESS); -} - -TEST_F(ObjectServiceImplTest, OnUserChange_NotAccountSwitched_OnlyCallsParent) -{ - // Given - uint32_t code = 0; // 不是账户切换 - std::string user = "testUser"; - std::string account = "testAccount"; - MockFeature::MockOnUserChangeReturns(OBJECT_SUCCESS); - - // When - int32_t result = objectServiceImpl->OnUserChange(code, user, account); - - // Then - EXPECT_EQ(result, OBJECT_SUCCESS); -} - -// ObjectStoreRevokeSave测试 -TEST_F(ObjectServiceImplTest, ObjectStoreRevokeSave_BundleNameCheckFailed_ReturnsError) -{ - // Given - std::string bundleName = "testBundle"; - std::string sessionId = "testSession"; - sptr callback = nullptr; - MockIPCSkeleton::MockGetCallingTokenIDReturns(123); - // 假设IsBundleNameEqualTokenId会失败 - MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_INNER_ERROR); - - // When - int32_t result = objectServiceImpl->ObjectStoreRevokeSave(bundleName, sessionId, callback); - - // Then - EXPECT_EQ(result, OBJECT_INNER_ERROR); -} - -TEST_F(ObjectServiceImplTest, ObjectStoreRevokeSave_RevokeSaveFailed_ReturnsError) -{ - // Given - std::string bundleName = "testBundle"; - std::string sessionId = "testSession"; - sptr callback = nullptr; - MockIPCSkeleton::MockGetCallingTokenIDReturns(123); - MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_SUCCESS); - MockObjectStoreManager::MockRevokeSaveReturns(OBJECT_INNER_ERROR); - - // When - int32_t result = objectServiceImpl->ObjectStoreRevokeSave(bundleName, sessionId, callback); - - // Then - EXPECT_EQ(result, OBJECT_INNER_ERROR); -} - -TEST_F(ObjectServiceImplTest, ObjectStoreRevokeSave_NormalCase_ReturnsSuccess) -{ - // Given - std::string bundleName = "testBundle"; - std::string sessionId = "testSession"; - sptr callback = nullptr; - MockIPCSkeleton::MockGetCallingTokenIDReturns(123); - MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_SUCCESS); - MockObjectStoreManager::MockRevokeSaveReturns(OBJECT_SUCCESS); - - // When - int32_t result = objectServiceImpl->ObjectStoreRevokeSave(bundleName, sessionId, callback); - - // Then - EXPECT_EQ(result, OBJECT_SUCCESS); -} - -// ObjectStoreRetrieve测试 -TEST_F(ObjectServiceImplTest, ObjectStoreRetrieve_BundleNameCheckFailed_ReturnsError) -{ - // Given - std::string bundleName = "testBundle"; - std::string sessionId = "testSession"; - sptr callback = nullptr; - MockIPCSkeleton::MockGetCallingTokenIDReturns(123); - MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_INNER_ERROR); - - // When - int32_t result = objectServiceImpl->ObjectStoreRetrieve(bundleName, sessionId, callback); - - // Then - EXPECT_EQ(result, OBJECT_INNER_ERROR); -} - -TEST_F(ObjectServiceImplTest, ObjectStoreRetrieve_RetrieveFailed_ReturnsError) -{ - // Given - std::string bundleName = "testBundle"; - std::string sessionId = "testSession"; - sptr callback = nullptr; - MockIPCSkeleton::MockGetCallingTokenIDReturns(123); - MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_SUCCESS); - MockObjectStoreManager::MockRetrieveReturns(OBJECT_INNER_ERROR); - - // When - int32_t result = objectServiceImpl->ObjectStoreRetrieve(bundleName, sessionId, callback); - - // Then - EXPECT_EQ(result, OBJECT_INNER_ERROR); -} - -TEST_F(ObjectServiceImplTest, ObjectStoreRetrieve_NormalCase_ReturnsSuccess) -{ - // Given - std::string bundleName = "testBundle"; - std::string sessionId = "testSession"; - sptr callback = nullptr; - MockIPCSkeleton::MockGetCallingTokenIDReturns(123); - MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_SUCCESS); - MockObjectStoreManager::MockRetrieveReturns(OBJECT_SUCCESS); - - // When - int32_t result = objectServiceImpl->ObjectStoreRetrieve(bundleName, sessionId, callback); - - // Then - EXPECT_EQ(result, OBJECT_SUCCESS); -} - -// RegisterDataObserver测试 -TEST_F(ObjectServiceImplTest, RegisterDataObserver_BundleNameCheckFailed_ReturnsError) -{ - // Given - std::string bundleName = "testBundle"; - std::string sessionId = "testSession"; - sptr callback = nullptr; - MockIPCSkeleton::MockGetCallingTokenIDReturns(123); - MockIPCSkeleton::MockGetCallingPidReturns(456); - MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_INNER_ERROR); - - // When - int32_t result = objectServiceImpl->RegisterDataObserver(bundleName, sessionId, callback); - - // Then - EXPECT_EQ(result, OBJECT_INNER_ERROR); -} - -TEST_F(ObjectServiceImplTest, RegisterDataObserver_NormalCase_ReturnsSuccess) -{ - // Given - std::string bundleName = "testBundle"; - std::string sessionId = "testSession"; - sptr callback = nullptr; - MockIPCSkeleton::MockGetCallingTokenIDReturns(123); - MockIPCSkeleton::MockGetCallingPidReturns(456); - MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_SUCCESS); - MockObjectStoreManager::MockRegisterRemoteCallbackReturns(); - - // When - int32_t result = objectServiceImpl->RegisterDataObserver(bundleName, sessionId, callback); - - // Then - EXPECT_EQ(result, OBJECT_SUCCESS); -} - -// UnregisterDataChangeObserver测试 -TEST_F(ObjectServiceImplTest, UnregisterDataChangeObserver_BundleNameCheckFailed_ReturnsError) -{ - // Given - std::string bundleName = "testBundle"; - std::string sessionId = "testSession"; - MockIPCSkeleton::MockGetCallingTokenIDReturns(123); - MockIPCSkeleton::MockGetCallingPidReturns(456); - MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_INNER_ERROR); - - // When - int32_t result = objectServiceImpl->UnregisterDataChangeObserver(bundleName, sessionId); - - // Then - EXPECT_EQ(result, OBJECT_INNER_ERROR); -} - -TEST_F(ObjectServiceImplTest, UnregisterDataChangeObserver_NormalCase_ReturnsSuccess) -{ - // Given - std::string bundleName = "testBundle"; - std::string sessionId = "testSession"; - MockIPCSkeleton::MockGetCallingTokenIDReturns(123); - MockIPCSkeleton::MockGetCallingPidReturns(456); - MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_SUCCESS); - MockObjectStoreManager::MockUnregisterRemoteCallbackReturns(); - - // When - int32_t result = objectServiceImpl->UnregisterDataChangeObserver(bundleName, sessionId); - - // Then - EXPECT_EQ(result, OBJECT_SUCCESS); -} - -// RegisterProgressObserver测试 -TEST_F(ObjectServiceImplTest, RegisterProgressObserver_BundleNameCheckFailed_ReturnsError) -{ - // Given - std::string bundleName = "testBundle"; - std::string sessionId = "testSession"; - sptr callback = nullptr; - MockIPCSkeleton::MockGetCallingTokenIDReturns(123); - MockIPCSkeleton::MockGetCallingPidReturns(456); - MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_INNER_ERROR); - - // When - int32_t result = objectServiceImpl->RegisterProgressObserver(bundleName, sessionId, callback); - - // Then - EXPECT_EQ(result, OBJECT_INNER_ERROR); -} - -TEST_F(ObjectServiceImplTest, RegisterProgressObserver_NormalCase_ReturnsSuccess) -{ - // Given - std::string bundleName = "testBundle"; - std::string sessionId = "testSession"; - sptr callback = nullptr; - MockIPCSkeleton::MockGetCallingTokenIDReturns(123); - MockIPCSkeleton::MockGetCallingPidReturns(456); - MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_SUCCESS); - MockObjectStoreManager::MockRegisterProgressObserverCallbackReturns(); - - // When - int32_t result = objectServiceImpl->RegisterProgressObserver(bundleName, sessionId, callback); - - // Then - EXPECT_EQ(result, OBJECT_SUCCESS); -} - -// UnregisterProgressObserver测试 -TEST_F(ObjectServiceImplTest, UnregisterProgressObserver_BundleNameCheckFailed_ReturnsError) -{ - // Given - std::string bundleName = "testBundle"; - std::string sessionId = "testSession"; - MockIPCSkeleton::MockGetCallingTokenIDReturns(123); - MockIPCSkeleton::MockGetCallingPidReturns(456); - MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_INNER_ERROR); - - // When - int32_t result = objectServiceImpl->UnregisterProgressObserver(bundleName, sessionId); - - // Then - EXPECT_EQ(result, OBJECT_INNER_ERROR); -} - -TEST_F(ObjectServiceImplTest, UnregisterProgressObserver_NormalCase_ReturnsSuccess) -{ - // Given - std::string bundleName = "testBundle"; - std::string sessionId = "testSession"; - MockIPCSkeleton::MockGetCallingTokenIDReturns(123); - MockIPCSkeleton::MockGetCallingPidReturns(456); - MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_SUCCESS); - MockObjectStoreManager::MockUnregisterProgressObserverCallbackReturns(); - - // When - int32_t result = objectServiceImpl->UnregisterProgressObserver(bundleName, sessionId); - - // Then - EXPECT_EQ(result, OBJECT_SUCCESS); -} - -// DeleteSnapshot测试 -TEST_F(ObjectServiceImplTest, DeleteSnapshot_BundleNameCheckFailed_ReturnsError) -{ - // Given - std::string bundleName = "testBundle"; - std::string sessionId = "testSession"; - MockIPCSkeleton::MockGetCallingTokenIDReturns(123); - MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_INNER_ERROR); - - // When - int32_t result = objectServiceImpl->DeleteSnapshot(bundleName, sessionId); - - // Then - EXPECT_EQ(result, OBJECT_INNER_ERROR); -} - -TEST_F(ObjectServiceImplTest, DeleteSnapshot_NormalCase_ReturnsSuccess) -{ - // Given - std::string bundleName = "testBundle"; - std::string sessionId = "testSession"; - MockIPCSkeleton::MockGetCallingTokenIDReturns(123); - MockObjectServiceImpl::MockIsBundleNameEqualTokenIdReturns(OBJECT_SUCCESS); - MockObjectStoreManager::MockDeleteSnapshotReturns(); - - // When - int32_t result = objectServiceImpl->DeleteSnapshot(bundleName, sessionId); - - // Then - EXPECT_EQ(result, OBJECT_SUCCESS); -} - - -/** - * @tc.name: IsNeedMetaSync001 - * @tc.desc: Test IsNeedMetaSync when LoadMeta fails for CapMetaData. - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(ObjectServiceImpMocklTest, IsNeedMetaSync001, TestSize.Level0) -{ - EXPECT_CALL(*fileDaemonMgrMock, RegisterAssetCallback(_)).WillOnce(testing::Return(0)); - auto &manager = ObjectStoreManager::GetInstance(); - StoreMetaData meta; - meta.deviceId = "test_device_id"; - meta.user = "0"; - meta.storeId = "distributedObject_"; - meta.bundleName = "test_bundle"; - std::vector uuids = { "test_uuid" }; - - EXPECT_CALL(*metaDataManagerMock, LoadMeta(testing::_, testing::_, testing::_)).WillOnce(testing::Return(false)); - bool isNeedSync = manager.IsNeedMetaSync(meta, uuids); - EXPECT_EQ(isNeedSync, true); - EXPECT_CALL(*metaDataManagerMock, LoadMeta(testing::_, testing::_, testing::_)) - .WillOnce(testing::Return(true)) - .WillOnce(testing::Return(false)); - isNeedSync = manager.IsNeedMetaSync(meta, uuids); - EXPECT_EQ(isNeedSync, true); -} - -/** - * @tc.name: IsNeedMetaSync002 - * @tc.desc: Test IsNeedMetaSync when LoadMeta fails for StoreMetaData. - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(ObjectServiceImpMocklTest, IsNeedMetaSync002, TestSize.Level0) -{ - auto &manager = ObjectStoreManager::GetInstance(); - StoreMetaData meta; - meta.deviceId = "test_device_id"; - meta.user = "0"; - meta.storeId = "distributedObject_"; - meta.bundleName = "test_bundle"; - std::vector uuids = { "test_uuid" }; - - EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)).WillRepeatedly(Return((true))); - EXPECT_CALL(*deviceMatrixMock, GetRemoteMask(_, _)) - .WillRepeatedly(Return(std::make_pair(true, DeviceMatrix::META_STORE_MASK))); - - bool result = manager.IsNeedMetaSync(meta, uuids); - EXPECT_EQ(result, true); -} - -/** - * @tc.name: IsNeedMetaSync003 - * @tc.desc: Test IsNeedMetaSync when LoadMeta fails for StoreMetaData. - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(ObjectServiceImpMocklTest, IsNeedMetaSync003, TestSize.Level0) -{ - auto &manager = ObjectStoreManager::GetInstance(); - StoreMetaData meta; - meta.deviceId = "test_device_id"; - meta.user = "0"; - meta.storeId = "distributedObject_"; - meta.bundleName = "test_bundle"; - std::vector uuids = { "test_uuid" }; - - EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)).WillRepeatedly(Return(true)); - EXPECT_CALL(*deviceMatrixMock, GetRemoteMask(_, _)).WillOnce(Return(std::make_pair(true, 0))); - EXPECT_CALL(*deviceMatrixMock, GetMask(_, _)).WillOnce(Return(std::make_pair(true, DeviceMatrix::META_STORE_MASK))); - - bool result = manager.IsNeedMetaSync(meta, uuids); - EXPECT_EQ(result, true); - - EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)).WillRepeatedly(Return(true)); - - EXPECT_CALL(*deviceMatrixMock, GetRemoteMask(_, _)).WillOnce(Return(std::make_pair(true, 0))); - - EXPECT_CALL(*deviceMatrixMock, GetMask(_, _)).WillOnce(Return(std::make_pair(true, 0))); - - result = manager.IsNeedMetaSync(meta, uuids); - EXPECT_EQ(result, false); -} - -/** - * @tc.name: SyncOnStore001 - * @tc.desc: Test SyncOnStore. - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(ObjectServiceImpMocklTest, SyncOnStore001, TestSize.Level0) -{ - // 2 means that the GetUserByToken interface will be called twice - EXPECT_CALL(*accountDelegateMock, GetUserByToken(_)).Times(2).WillRepeatedly(Return(0)); - auto &manager = ObjectStoreManager::GetInstance(); - std::function &results)> func; - func = [](const std::map &results) { return results; }; - std::string prefix = "ObjectManagerTest"; - StoreMetaData meta; - meta.deviceId = "test_device_id"; - meta.user = "0"; - meta.storeId = "distributedObject_"; - meta.bundleName = "test_bundle"; - std::vector uuids = { "test_uuid" }; - - // local device - { - std::vector localDeviceList = { "local" }; - auto result = manager.SyncOnStore(prefix, localDeviceList, func); - EXPECT_EQ(result, OBJECT_SUCCESS); - } - - // remote device. IsNeedMetaSync: true; Sync: true - { - std::vector remoteDeviceList = { "remote_device_1" }; - EXPECT_CALL(*devMgrAdapterMock, GetUuidByNetworkId(_)).WillRepeatedly(Return("mock_uuid")); - EXPECT_CALL(*devMgrAdapterMock, ToUUID(testing::A &>())) - .WillOnce(Return(std::vector{ "mock_uuid_1" })); - EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)).WillOnce(testing::Return(false)); - EXPECT_CALL(*metaDataManagerMock, Sync(_, _, _)).WillOnce(testing::Return(true)); - auto result = manager.SyncOnStore(prefix, remoteDeviceList, func); - EXPECT_EQ(result, OBJECT_SUCCESS); - } - - // remote device. IsNeedMetaSync: false - { - std::vector remoteDeviceList = { "remote_device_1" }; - EXPECT_CALL(*devMgrAdapterMock, GetUuidByNetworkId(_)).WillRepeatedly(Return("mock_uuid")); - EXPECT_CALL(*devMgrAdapterMock, ToUUID(testing::A &>())) - .WillOnce(Return(std::vector{ "mock_uuid_1" })); - EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)) - .WillOnce(testing::Return(true)) - .WillOnce(testing::Return(true)); - EXPECT_CALL(*deviceMatrixMock, GetRemoteMask(_, _)).WillOnce(Return(std::make_pair(true, 0))); - EXPECT_CALL(*deviceMatrixMock, GetMask(_, _)).WillOnce(Return(std::make_pair(true, 0))); - auto result = manager.SyncOnStore(prefix, remoteDeviceList, func); - EXPECT_EQ(result, E_DB_ERROR); - } -} - -/** -* @tc.name: GetCurrentUser001 -* @tc.desc: Test the scenario where the QueryUsers return false in the GetCurrentUser function. -* @tc.type: FUNC -* @tc.require: -* @tc.author: -*/ -HWTEST_F(ObjectServiceImpMocklTest, GetCurrentUser001, TestSize.Level1) -{ - auto &manager = ObjectStoreManager::GetInstance(); - std::vector users; - EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(users), Return(false))); - auto result = manager.GetCurrentUser(); - EXPECT_EQ(result, ""); -} - -/** -* @tc.name: GetCurrentUser002 -* @tc.desc: Test the scenario where the QueryUsers users empty in the GetCurrentUser function. -* @tc.type: FUNC -* @tc.require: -* @tc.author: -*/ -HWTEST_F(ObjectServiceImpMocklTest, GetCurrentUser002, TestSize.Level1) -{ - auto &manager = ObjectStoreManager::GetInstance(); - std::vector users; - EXPECT_CALL(*accountDelegateMock, QueryUsers(_)) - .Times(1) - .WillOnce( - DoAll(SetArgReferee<0>(users), Invoke([](std::vector &users) { users.clear(); }), Return(true))); - auto result = manager.GetCurrentUser(); - EXPECT_EQ(result, ""); -} - -/** -* @tc.name: GetCurrentUser003 -* @tc.desc: Test the scenario where the QueryUsers return true in the GetCurrentUser function. -* @tc.type: FUNC -* @tc.require: -* @tc.author: -*/ -HWTEST_F(ObjectServiceImpMocklTest, GetCurrentUser003, TestSize.Level1) -{ - auto &manager = ObjectStoreManager::GetInstance(); - std::vector users = { 0, 1 }; - EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(users), Return(true))); - auto result = manager.GetCurrentUser(); - EXPECT_EQ(result, std::to_string(users[0])); -} - -/** -* @tc.name: WaitAssets001 -* @tc.desc: WaitAssets test. -* @tc.type: FUNC -*/ -HWTEST_F(ObjectServiceImpMocklTest, WaitAssets001, TestSize.Level1) -{ - auto &manager = ObjectStoreManager::GetInstance(); - std::string objectKey = "objectKey"; - ObjectStoreManager::SaveInfo info; - std::map data; - auto ret = manager.WaitAssets(objectKey, info, data); - EXPECT_EQ(ret, DistributedObject::OBJECT_INNER_ERROR); -} - -/** -* @tc.name: NotifyAssetsReady001 -* @tc.desc: NotifyAssetsReady test. -* @tc.type: FUNC -*/ -HWTEST_F(ObjectServiceImpMocklTest, NotifyAssetsReady001, TestSize.Level1) -{ - auto &manager = ObjectStoreManager::GetInstance(); - std::string objectKey = "objectKey"; - std::string bundleName = "bundleName"; - std::string srcNetworkId = "srcNetworkId"; - manager.NotifyAssetsReady(objectKey, bundleName, srcNetworkId); - EXPECT_EQ(manager.executors_, nullptr); -} - -/** -* @tc.name: DoNotifyAssetsReady001 -* @tc.desc: DoNotifyAssetsReady test. -* @tc.type: FUNC -*/ -HWTEST_F(ObjectServiceImpMocklTest, DoNotifyAssetsReady001, TestSize.Level1) -{ - auto &manager = ObjectStoreManager::GetInstance(); - uint32_t tokenId = 0; - ObjectStoreManager::CallbackInfo info; - std::string objectKey = "objectKey"; - bool isReady = true; - manager.DoNotifyAssetsReady(tokenId, info, objectKey, isReady); - EXPECT_EQ(manager.executors_, nullptr); -} - -/** -* @tc.name: DoNotifyWaitAssetTimeout001 -* @tc.desc: DoNotifyWaitAssetTimeout test. -* @tc.type: FUNC -*/ -HWTEST_F(ObjectServiceImpMocklTest, DoNotifyWaitAssetTimeout001, TestSize.Level1) -{ - auto &manager = ObjectStoreManager::GetInstance(); - std::string objectKey = "objectKey"; - manager.DoNotifyWaitAssetTimeout(objectKey); - EXPECT_EQ(manager.executors_, nullptr); -} - -/** -* @tc.name: FlushClosedStore001 -* @tc.desc: FlushClosedStore test. -* @tc.type: FUNC -*/ -HWTEST_F(ObjectServiceImpMocklTest, FlushClosedStore001, TestSize.Level1) -{ - auto &manager = ObjectStoreManager::GetInstance(); - manager.FlushClosedStore(); - EXPECT_EQ(manager.executors_, nullptr); -} - -/** -* @tc.name: CloseAfterMinute001 -* @tc.desc: CloseAfterMinute test. -* @tc.type: FUNC -*/ -HWTEST_F(ObjectServiceImpMocklTest, CloseAfterMinute001, TestSize.Level1) -{ - auto &manager = ObjectStoreManager::GetInstance(); - manager.CloseAfterMinute(); - EXPECT_EQ(manager.executors_, nullptr); -} - -/** -* @tc.name: UnRegisterAssetsLister001 -* @tc.desc: UnRegisterAssetsLister test. -* @tc.type: FUNC -*/ -HWTEST_F(ObjectServiceImpMocklTest, UnRegisterAssetsLister001, TestSize.Level1) -{ - auto &manager = ObjectStoreManager::GetInstance(); - manager.objectAssetsRecvListener_ = nullptr; - auto ret = manager.UnRegisterAssetsLister(); - EXPECT_EQ(ret, true); - EXPECT_CALL(*fileDaemonMgrMock, RegisterAssetCallback(_)).WillOnce(testing::Return(0)); - manager.RegisterAssetsLister(); - EXPECT_CALL(*fileDaemonMgrMock, UnRegisterAssetCallback(_)).WillOnce(testing::Return(-1)); - ret = manager.UnRegisterAssetsLister(); - EXPECT_EQ(ret, false); - EXPECT_CALL(*fileDaemonMgrMock, UnRegisterAssetCallback(_)).WillOnce(testing::Return(0)); - ret = manager.UnRegisterAssetsLister(); - EXPECT_EQ(ret, true); -} - -/** -* @tc.name: InitUserMeta001 -* @tc.desc: Test the scenario where the QueryUsers return false in the GetCurrentUser function. -* @tc.type: FUNC -*/ -HWTEST_F(ObjectServiceImpMocklTest, InitUserMeta001, TestSize.Level1) -{ - EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)) - .WillOnce(testing::Return(false)); - auto &manager = ObjectStoreManager::GetInstance(); - std::vector users; - EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(users), Return(false))); - auto status = manager.InitUserMeta(); - EXPECT_EQ(status, DistributedObject::OBJECT_INNER_ERROR); -} - -/** -* @tc.name: InitUserMeta002 -* @tc.desc: Test the scenario where the QueryUsers users empty in the GetCurrentUser function. -* @tc.type: FUNC -*/ -HWTEST_F(ObjectServiceImpMocklTest, InitUserMeta002, TestSize.Level1) -{ - EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)) - .WillOnce(testing::Return(false)); - auto &manager = ObjectStoreManager::GetInstance(); - std::vector users; - EXPECT_CALL(*accountDelegateMock, QueryUsers(_)) - .Times(1) - .WillOnce( - DoAll(SetArgReferee<0>(users), Invoke([](std::vector &users) { users.clear(); }), Return(true))); - auto status = manager.InitUserMeta(); - EXPECT_EQ(status, DistributedObject::OBJECT_INNER_ERROR); -} - -/** -* @tc.name: InitUserMeta003 -* @tc.desc: Test the scenario where the QueryUsers return true in the GetCurrentUser function. -* @tc.type: FUNC -*/ -HWTEST_F(ObjectServiceImpMocklTest, InitUserMeta003, TestSize.Level1) -{ - EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)) - .WillOnce(testing::Return(false)); - DeviceInfo devInfo = { .uuid = "666" }; - EXPECT_CALL(*devMgrAdapterMock, GetLocalDevice()).WillOnce(Return(devInfo)); - auto &manager = ObjectStoreManager::GetInstance(); - std::vector users = { 0, 1 }; - EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(users), Return(true))); - auto status = manager.InitUserMeta(); - EXPECT_EQ(status, DistributedObject::OBJECT_INNER_ERROR); -} - -/** -* @tc.name: BindAsset001 -* @tc.desc: Test BindAsset function when GetTokenTypeFlag is not TOKEN_HAP. -* @tc.type: FUNC -*/ -HWTEST_F(ObjectServiceImpMocklTest, BindAsset001, TestSize.Level1) -{ - auto &manager = ObjectStoreManager::GetInstance(); - std::string bundleName = "BindAsset"; - uint32_t tokenId = IPCSkeleton::GetCallingTokenID(); - EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(_)) - .Times(1) - .WillOnce(Return(ATokenTypeEnum::TOKEN_NATIVE)); - auto result = manager.BindAsset(tokenId, bundleName, sessionId_, assetValue_, assetBindInfo_); - EXPECT_EQ(result, DistributedObject::OBJECT_DBSTATUS_ERROR); -} - -/** -* @tc.name: BindAsset002 -* @tc.desc: Test BindAsset function when GetTokenTypeFlag is TOKEN_HAP. -* @tc.type: FUNC -*/ -HWTEST_F(ObjectServiceImpMocklTest, BindAsset002, TestSize.Level1) -{ - auto &manager = ObjectStoreManager::GetInstance(); - std::string bundleName = "BindAsset"; - uint32_t tokenId = IPCSkeleton::GetCallingTokenID(); - EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(_)) - .Times(1) - .WillOnce(Return(ATokenTypeEnum::TOKEN_HAP)); - EXPECT_CALL(*accTokenMock, GetHapTokenInfo(_, _)) - .Times(1) - .WillOnce(Return(0)); - auto result = manager.BindAsset(tokenId, bundleName, sessionId_, assetValue_, assetBindInfo_); - EXPECT_EQ(result, DistributedObject::OBJECT_SUCCESS); -} - -/** -* @tc.name: IsContinue001 -* @tc.desc: Test IsContinue function when GetTokenTypeFlag is not TOKEN_HAP. -* @tc.type: FUNC -*/ -HWTEST_F(ObjectServiceImpMocklTest, IsContinue001, TestSize.Level1) -{ - std::shared_ptr objectServiceImpl = std::make_shared(); - bool isContinue = false; - EXPECT_CALL(*fileDaemonMgrMock, UnRegisterAssetCallback(_)).WillRepeatedly(testing::Return(0)); - EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(_)) - .Times(1) - .WillOnce(Return(ATokenTypeEnum::TOKEN_NATIVE)); - auto ret = objectServiceImpl->IsContinue(isContinue); - EXPECT_EQ(ret, DistributedObject::OBJECT_INNER_ERROR); -} - -/** -* @tc.name: IsContinue002 -* @tc.desc: Test IsContinue function when GetTokenTypeFlag is TOKEN_HAP. -* @tc.type: FUNC -*/ -HWTEST_F(ObjectServiceImpMocklTest, IsContinue002, TestSize.Level1) -{ - std::shared_ptr objectServiceImpl = std::make_shared(); - bool isContinue = false; - EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(_)) - .Times(2) - .WillRepeatedly(Return(ATokenTypeEnum::TOKEN_HAP)); - EXPECT_CALL(*accTokenMock, GetHapTokenInfo(_, _)) - .Times(1) - .WillOnce(Return(0)); - auto ret = objectServiceImpl->IsContinue(isContinue); - EXPECT_EQ(ret, DistributedObject::OBJECT_SUCCESS); -} -}; // namespace DistributedDataTest -} // namespace OHOS::Test \ No newline at end of file -- Gitee From 3109d2eaf8bb2e0a1ed1f927a200e7488def858a Mon Sep 17 00:00:00 2001 From: gecheng Date: Thu, 7 Aug 2025 20:23:46 +0800 Subject: [PATCH 4/6] =?UTF-8?q?TOKEN=5FHAP=E7=B1=BB=E5=9E=8B=E6=A0=A1?= =?UTF-8?q?=E9=AA=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../service/test/cloud_data_mock_test.cpp | 5 ++++- .../service/test/mock/access_token_mock.cpp | 3 +++ .../service/test/object_manager_mock_test.cpp | 4 ++-- 3 files changed, 9 insertions(+), 3 deletions(-) diff --git a/services/distributeddataservice/service/test/cloud_data_mock_test.cpp b/services/distributeddataservice/service/test/cloud_data_mock_test.cpp index 0598f4b8c..736a1d3df 100644 --- a/services/distributeddataservice/service/test/cloud_data_mock_test.cpp +++ b/services/distributeddataservice/service/test/cloud_data_mock_test.cpp @@ -47,6 +47,7 @@ static constexpr const char *TEST_CLOUD_DATABASE_ALIAS_1 = "test_cloud_database_ static constexpr const char *TEST_CLOUD_DATABASE_ALIAS_2 = "test_cloud_database_alias_2"; static constexpr const char *TEST_CLOUD_PATH = "/data/app/el2/100/database/test_cloud_bundleName/entry/rdb/" "test_cloud_store"; +static constexpr const int32_t TEST_TOKEN_FLAG_CALL_COUNT = 3; class CloudDataMockTest : public testing::Test { public: static void SetUpTestCase(void); @@ -191,7 +192,9 @@ void CloudDataMockTest::SetUpTestCase(void) accTokenMock = std::make_shared(); BAccessTokenKit::accessTokenkit = accTokenMock; - EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(_)).Times(3).WillRepeatedly(Return(ATokenTypeEnum::TOKEN_HAP)); + EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(_)) + .Times(TEST_TOKEN_FLAG_CALL_COUNT) + .WillRepeatedly(Return(ATokenTypeEnum::TOKEN_HAP)); MetaDataManager::GetInstance().Initialize(dbStoreMock_, nullptr, ""); MetaDataManager::GetInstance().SetSyncer( diff --git a/services/distributeddataservice/service/test/mock/access_token_mock.cpp b/services/distributeddataservice/service/test/mock/access_token_mock.cpp index c0fe454a6..e3e5addd4 100644 --- a/services/distributeddataservice/service/test/mock/access_token_mock.cpp +++ b/services/distributeddataservice/service/test/mock/access_token_mock.cpp @@ -19,6 +19,9 @@ namespace Security { namespace AccessToken { ATokenTypeEnum AccessTokenKit::GetTokenTypeFlag(AccessTokenID tokenID) { + if (BAccessTokenKit::accessTokenkit == nullptr) { + return ATokenTypeEnum::TOKEN_INVALID; + } return BAccessTokenKit::accessTokenkit->GetTokenTypeFlag(tokenID); } diff --git a/services/distributeddataservice/service/test/object_manager_mock_test.cpp b/services/distributeddataservice/service/test/object_manager_mock_test.cpp index e86596028..988dbcdae 100644 --- a/services/distributeddataservice/service/test/object_manager_mock_test.cpp +++ b/services/distributeddataservice/service/test/object_manager_mock_test.cpp @@ -496,7 +496,7 @@ HWTEST_F(ObjectManagerMockTest, IsContinue001, TestSize.Level1) EXPECT_CALL(*accTokenMock, GetTokenTypeFlag(_)) .Times(1) .WillOnce(Return(ATokenTypeEnum::TOKEN_NATIVE)); - auto ret = objectServiceImpl->IsContinue(isContinue); + auto ret = objectServiceImpl->IsContinue(isContinue); EXPECT_EQ(ret, DistributedObject::OBJECT_INNER_ERROR); } @@ -515,7 +515,7 @@ HWTEST_F(ObjectManagerMockTest, IsContinue002, TestSize.Level1) EXPECT_CALL(*accTokenMock, GetHapTokenInfo(_, _)) .Times(1) .WillOnce(Return(0)); - auto ret = objectServiceImpl->IsContinue(isContinue); + auto ret = objectServiceImpl->IsContinue(isContinue); EXPECT_EQ(ret, DistributedObject::OBJECT_SUCCESS); } }; // namespace DistributedDataTest -- Gitee From 2fd8c798f6c939f18c47bafb0ac834d084366e82 Mon Sep 17 00:00:00 2001 From: gecheng Date: Thu, 7 Aug 2025 21:16:26 +0800 Subject: [PATCH 5/6] =?UTF-8?q?TOKEN=5FHAP=E7=B1=BB=E5=9E=8B=E6=A0=A1?= =?UTF-8?q?=E9=AA=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../service/test/cloud_data_mock_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/services/distributeddataservice/service/test/cloud_data_mock_test.cpp b/services/distributeddataservice/service/test/cloud_data_mock_test.cpp index 736a1d3df..5f7e68b9d 100644 --- a/services/distributeddataservice/service/test/cloud_data_mock_test.cpp +++ b/services/distributeddataservice/service/test/cloud_data_mock_test.cpp @@ -47,7 +47,7 @@ static constexpr const char *TEST_CLOUD_DATABASE_ALIAS_1 = "test_cloud_database_ static constexpr const char *TEST_CLOUD_DATABASE_ALIAS_2 = "test_cloud_database_alias_2"; static constexpr const char *TEST_CLOUD_PATH = "/data/app/el2/100/database/test_cloud_bundleName/entry/rdb/" "test_cloud_store"; -static constexpr const int32_t TEST_TOKEN_FLAG_CALL_COUNT = 3; +static constexpr const int32_t TEST_TOKEN_FLAG_CALL_COUNT = 3; class CloudDataMockTest : public testing::Test { public: static void SetUpTestCase(void); -- Gitee From 7fb853530a7e44427ae80336e040c2680b8a059a Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 12 Aug 2025 20:01:40 +0800 Subject: [PATCH 6/6] =?UTF-8?q?TOKEN=5FHAP=E7=B1=BB=E5=9E=8B=E6=A0=A1?= =?UTF-8?q?=E9=AA=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../distributeddataservice/service/cloud/cloud_service_impl.cpp | 1 + .../distributeddataservice/service/object/src/object_manager.cpp | 1 + .../service/object/src/object_service_impl.cpp | 1 + 3 files changed, 3 insertions(+) diff --git a/services/distributeddataservice/service/cloud/cloud_service_impl.cpp b/services/distributeddataservice/service/cloud/cloud_service_impl.cpp index 3747384aa..2e89e572c 100644 --- a/services/distributeddataservice/service/cloud/cloud_service_impl.cpp +++ b/services/distributeddataservice/service/cloud/cloud_service_impl.cpp @@ -1601,6 +1601,7 @@ std::vector CloudServiceImpl::ConvertCursor(std::shared CloudServiceImpl::HapInfo CloudServiceImpl::GetHapInfo(uint32_t tokenId) { if (AccessTokenKit::GetTokenTypeFlag(tokenId) != TOKEN_HAP) { + ZLOGE("TokenType is not TOKEN_HAP, tokenId:0x%{public}x", tokenId); return { 0, 0, ""}; } HapTokenInfo tokenInfo; diff --git a/services/distributeddataservice/service/object/src/object_manager.cpp b/services/distributeddataservice/service/object/src/object_manager.cpp index c95f16ad8..66d35fd0c 100644 --- a/services/distributeddataservice/service/object/src/object_manager.cpp +++ b/services/distributeddataservice/service/object/src/object_manager.cpp @@ -1456,6 +1456,7 @@ int32_t ObjectStoreManager::BindAsset(const uint32_t tokenId, const std::string& }); if (AccessTokenKit::GetTokenTypeFlag(tokenId) != TOKEN_HAP) { + ZLOGE("TokenType is not TOKEN_HAP, token:0x%{public}x, bundleName:%{public}s", tokenId, appId.c_str()); return GeneralError::E_ERROR; } HapTokenInfo tokenInfo; diff --git a/services/distributeddataservice/service/object/src/object_service_impl.cpp b/services/distributeddataservice/service/object/src/object_service_impl.cpp index 2fae655cf..ff6d5ee3a 100644 --- a/services/distributeddataservice/service/object/src/object_service_impl.cpp +++ b/services/distributeddataservice/service/object/src/object_service_impl.cpp @@ -118,6 +118,7 @@ int32_t ObjectServiceImpl::IsContinue(bool &result) { uint32_t tokenId = IPCSkeleton::GetCallingTokenID(); if (Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(tokenId) != Security::AccessToken::TOKEN_HAP) { + ZLOGE("TokenType is not TOKEN_HAP, tokenId: %{public}u", tokenId); return OBJECT_INNER_ERROR; } Security::AccessToken::HapTokenInfo tokenInfo; -- Gitee