diff --git a/services/distributeddataservice/app/test/mock/capability/metadata/meta_data_manager.h b/services/distributeddataservice/app/test/mock/capability/metadata/meta_data_manager.h
index 8fbf3814f1d1525ded5214d61f4038de0de9a52c..751fd01fad1b349e0db8cb53f559279d045399ea 100644
--- a/services/distributeddataservice/app/test/mock/capability/metadata/meta_data_manager.h
+++ b/services/distributeddataservice/app/test/mock/capability/metadata/meta_data_manager.h
@@ -32,6 +32,7 @@ public:
     };
 
     using Observer = std::function<bool(const std::string &, const std::string &, int32_t)>;
+    using OnComplete = std::function<void(const std::map<std::string, int32_t> &)>;
 
     static MetaDataManager &GetInstance();
     void Init(std::shared_ptr<ExecutorPool> executors);
@@ -41,7 +42,7 @@ public:
     void UnSubscribe();
     bool UpdateMeta(const std::string &key, const CapMetaData &value);
     bool DeleteMeta(const std::string &key, const CapMetaData &value);
-
+    bool Sync(const std::vector<std::string> &devices, OnComplete onComplete);
 private:
     MetaDataManager() = default;
     ~MetaDataManager() = default;
diff --git a/services/distributeddataservice/service/object/BUILD.gn b/services/distributeddataservice/service/object/BUILD.gn
index 35412b7339eb950897272089f118acf3bffbec75..7ebc673313d939321486b3932fbabfe1ffd857b4 100644
--- a/services/distributeddataservice/service/object/BUILD.gn
+++ b/services/distributeddataservice/service/object/BUILD.gn
@@ -18,6 +18,7 @@ config("object_public_config") {
 
   include_dirs = [
     "${data_service_path}/service/common",
+    "${data_service_path}/service/matrix/include",
     "${data_service_path}/adapter/include/communicator",
     "${data_service_path}/adapter/include/utils",
   ]
diff --git a/services/distributeddataservice/service/object/include/object_manager.h b/services/distributeddataservice/service/object/include/object_manager.h
index c87f1196a38ce52ad09aae8655197174e781144a..7a87246efc78e388542859854d3703bd516849aa 100644
--- a/services/distributeddataservice/service/object/include/object_manager.h
+++ b/services/distributeddataservice/service/object/include/object_manager.h
@@ -21,6 +21,7 @@
 #include "device_manager_adapter.h"
 #include "kv_store_delegate_manager.h"
 #include "kvstore_sync_callback.h"
+#include "metadata/store_meta_data.h"
 #include "object_asset_loader.h"
 #include "object_callback.h"
 #include "object_callback_proxy.h"
@@ -64,6 +65,7 @@ class ObjectStoreManager {
 public:
     using DmAdaper = OHOS::DistributedData::DeviceManagerAdapter;
     using UriToSnapshot = std::shared_ptr<std::map<std::string, std::shared_ptr<Snapshot>>>;
+    using StoreMetaData = OHOS::DistributedData::StoreMetaData;
 
     enum RestoreStatus : int32_t {
         NONE = 0,
@@ -162,6 +164,11 @@ private:
     void ProcessSyncCallback(const std::map<std::string, int32_t> &results, const std::string &appId,
         const std::string &sessionId, const std::string &deviceId);
     void SaveUserToMeta();
+    int32_t StoreMetaAndDoSync(const std::string &dstBundleName, const std::string &deviceId,
+        const std::string &sessionId, sptr<ObjectSaveCallbackProxy> proxy);
+    int32_t DoSyncOnStore(const std::string &dstBundleName, const std::string &deviceId, const std::string &sessionId,
+        sptr<ObjectSaveCallbackProxy> proxy);
+    bool IsNeedMetaSync(const StoreMetaData &meta, const std::vector<std::string> &networkIds);
     std::string GetCurrentUser();
     void DoNotify(uint32_t tokenId, const CallbackInfo& value, const std::map<std::string, ObjectRecord>& data,
         bool allReady);
diff --git a/services/distributeddataservice/service/object/src/object_manager.cpp b/services/distributeddataservice/service/object/src/object_manager.cpp
index 958470f18cce7a13ca498683ee70ae92ac86761d..b16ad53caadaedfa4bfdc1f2c0f63c413f9e9650 100644
--- a/services/distributeddataservice/service/object/src/object_manager.cpp
+++ b/services/distributeddataservice/service/object/src/object_manager.cpp
@@ -25,9 +25,12 @@
 #include "common/bytes.h"
 #include "common/string_utils.h"
 #include "datetime_ex.h"
+#include "device_matrix.h"
 #include "distributed_file_daemon_manager.h"
 #include "kvstore_utils.h"
 #include "log_print.h"
+#include "ipc_skeleton.h"
+#include "metadata/capability_meta_data.h"
 #include "metadata/meta_data_manager.h"
 #include "metadata/object_user_meta_data.h"
 #include "metadata/store_meta_data.h"
@@ -44,7 +47,9 @@ using Account = OHOS::DistributedData::AccountDelegate;
 using AccessTokenKit = Security::AccessToken::AccessTokenKit;
 using ValueProxy = OHOS::DistributedData::ValueProxy;
 using DistributedFileDaemonManager = Storage::DistributedFile::DistributedFileDaemonManager;
+using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter;
 constexpr const char *SAVE_INFO = "p_###SAVEINFO###";
+constexpr const char *DEFAULT_USERID = "0";
 ObjectStoreManager::ObjectStoreManager()
 {
     ZLOGI("ObjectStoreManager construct");
@@ -156,23 +161,18 @@ int32_t ObjectStoreManager::Save(const std::string &appId, const std::string &se
         proxy->Completed(std::map<std::string, int32_t>());
         return result;
     }
-    ZLOGI("Sync data, bundleName: %{public}s, sessionId: %{public}s, deviceId: %{public}s", dstBundleName.c_str(),
-        sessionId.c_str(), Anonymous::Change(deviceId).c_str());
-    SyncCallBack syncCallback =
-        [proxy, dstBundleName, sessionId, deviceId, this](const std::map<std::string, int32_t> &results) {
-            ProcessSyncCallback(results, dstBundleName, sessionId, deviceId);
-            proxy->Completed(results);
-        };
-    result = SyncOnStore(GetPropertyPrefix(dstBundleName, sessionId, deviceId), {deviceId}, syncCallback);
+    if (deviceId == LOCAL_DEVICE) {
+        ZLOGI("Save to local, do not need sync");
+        std::map<std::string, int32_t> results = {{LOCAL_DEVICE, OBJECT_SUCCESS}};
+        ProcessSyncCallback(results, dstBundleName, sessionId, deviceId);
+        proxy->Completed(results);
+        return SUCCESS;
+    }
+    result = StoreMetaAndDoSync(dstBundleName, deviceId, sessionId, proxy);
     if (result != OBJECT_SUCCESS) {
-        ZLOGE("Sync data failed, result: %{public}d", result);
-        ObjectStore::RadarReporter::ReportStateError(std::string(__FUNCTION__), ObjectStore::SAVE,
-            ObjectStore::SYNC_DATA, ObjectStore::RADAR_FAILED, result, ObjectStore::FINISHED);
-        Close();
-        proxy->Completed(std::map<std::string, int32_t>());
+        ZLOGE("Save meta data and sync data failed, result: %{public}d", result);
         return result;
     }
-    Close();
     return PushAssets(appId, dstBundleName, sessionId, data, deviceId);
 }
 
@@ -919,10 +919,6 @@ int32_t ObjectStoreManager::SyncOnStore(
             callback({{LOCAL_DEVICE, OBJECT_SUCCESS}});
             return OBJECT_SUCCESS;
         }
-        if (!DeviceManagerAdapter::GetInstance().IsSameAccount(device)) {
-            ZLOGE("IsSameAccount failed. device:%{public}s", Anonymous::Change(device).c_str());
-            continue;
-        }
         syncDevices.emplace_back(DmAdaper::GetInstance().GetUuidByNetworkId(device));
     }
     if (syncDevices.empty()) {
@@ -1128,6 +1124,87 @@ void ObjectStoreManager::SaveUserToMeta()
     }
 }
 
+bool ObjectStoreManager::IsNeedMetaSync(const StoreMetaData &meta, const std::vector<std::string> &uuids)
+{
+    bool isAfterMeta = false;
+    for (const auto &uuid : uuids) {
+        auto metaData = meta;
+        metaData.deviceId = uuid;
+        CapMetaData capMeta;
+        auto capKey = CapMetaRow::GetKeyFor(uuid);
+        bool flag = !MetaDataManager::GetInstance().LoadMeta(std::string(capKey.begin(), capKey.end()), capMeta) ||
+            !MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData);
+        if (flag) {
+            isAfterMeta = true;
+            break;
+        }
+        auto [exist, mask] = DeviceMatrix::GetInstance().GetRemoteMask(uuid);
+        if ((mask & DeviceMatrix::META_STORE_MASK) == DeviceMatrix::META_STORE_MASK) {
+            isAfterMeta = true;
+            break;
+        }
+        auto [existLocal, localMask] = DeviceMatrix::GetInstance().GetMask(uuid);
+        if ((localMask & DeviceMatrix::META_STORE_MASK) == DeviceMatrix::META_STORE_MASK) {
+            isAfterMeta = true;
+            break;
+        }
+    }
+    return isAfterMeta;
+}
+
+int32_t ObjectStoreManager::StoreMetaAndDoSync(const std::string &dstBundleName, const std::string &deviceId,
+    const std::string &sessionId, sptr<ObjectSaveCallbackProxy> proxy)
+{
+    const auto &localDeviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    if (localDeviceId.empty()) {
+        ZLOGE("localDeviceId is empty");
+        return OBJECT_INNER_ERROR;
+    }
+    StoreMetaData meta;
+    meta.deviceId = localDeviceId;
+    meta.user = DEFAULT_USERID;
+    meta.storeId = ObjectCommon::OBJECTSTORE_DB_STOREID;
+    meta.bundleName = Bootstrap::GetInstance().GetProcessLabel();
+    if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) {
+        ZLOGE("Failed to load meta data, key: %{public}s", meta.GetKey().c_str());
+        return OBJECT_INNER_ERROR;
+    }
+
+    const std::vector<std::string> uuids = {DmAdaper::GetInstance().GetUuidByNetworkId(deviceId)};
+    if (IsNeedMetaSync(meta, uuids) &&
+        !DistributedData::MetaDataManager::GetInstance().Sync(uuids,
+            [proxy, dstBundleName, sessionId, deviceId, this](auto &results) {
+                return DoSyncOnStore(dstBundleName, deviceId, sessionId, proxy);
+        })) {
+        ZLOGE("bundleName: %{public}s, meta sync failed", dstBundleName.c_str());
+        return OBJECT_INNER_ERROR;
+    }
+    return OBJECT_SUCCESS;
+}
+
+int32_t ObjectStoreManager::DoSyncOnStore(const std::string &dstBundleName, const std::string &deviceId,
+    const std::string &sessionId, sptr<ObjectSaveCallbackProxy> proxy)
+{
+    ZLOGI("Sync data, bundleName: %{public}s, sessionId: %{public}s, deviceId: %{public}s", dstBundleName.c_str(),
+        sessionId.c_str(), Anonymous::Change(deviceId).c_str());
+    SyncCallBack syncCallback =
+        [proxy, dstBundleName, sessionId, deviceId, this](const std::map<std::string, int32_t> &results) {
+            ProcessSyncCallback(results, dstBundleName, sessionId, deviceId);
+            proxy->Completed(results);
+        };
+    int32_t result = SyncOnStore(GetPropertyPrefix(dstBundleName, sessionId, deviceId), {deviceId}, syncCallback);
+    if (result != OBJECT_SUCCESS) {
+        ZLOGE("Sync data failed, result: %{public}d", result);
+        ObjectStore::RadarReporter::ReportStateError(std::string(__FUNCTION__), ObjectStore::SAVE,
+            ObjectStore::SYNC_DATA, ObjectStore::RADAR_FAILED, result, ObjectStore::FINISHED);
+        Close();
+        proxy->Completed(std::map<std::string, int32_t>());
+        return result;
+    }
+    Close();
+    return OBJECT_SUCCESS;
+}
+
 void ObjectStoreManager::CloseAfterMinute()
 {
     executors_->Schedule(std::chrono::minutes(INTERVAL), [this]() {
diff --git a/services/distributeddataservice/service/object/src/object_service_impl.cpp b/services/distributeddataservice/service/object/src/object_service_impl.cpp
index 5df3363c770e7da4ee9908f7d845c8cc698372f5..94e1c71f99357ce2c4f01775ed9a238b80237ad1 100644
--- a/services/distributeddataservice/service/object/src/object_service_impl.cpp
+++ b/services/distributeddataservice/service/object/src/object_service_impl.cpp
@@ -170,6 +170,7 @@ int32_t ObjectServiceImpl::SaveMetaData(StoreMetaData &saveMeta, const std::stri
     saveMeta.storeType = ObjectDistributedType::OBJECT_SINGLE_VERSION;
     saveMeta.dataType = DistributedKv::DataType::TYPE_DYNAMICAL;
     saveMeta.dataDir = DistributedData::DirectoryManager::GetInstance().GetStorePath(saveMeta);
+    saveMeta.authType = DistributedKv::AuthType::IDENTICAL_ACCOUNT;
     bool isSaved = DistributedData::MetaDataManager::GetInstance().SaveMeta(saveMeta.GetKey(), saveMeta) &&
                    DistributedData::MetaDataManager::GetInstance().SaveMeta(saveMeta.GetKey(), saveMeta, true);
     if (!isSaved) {
diff --git a/services/distributeddataservice/service/test/BUILD.gn b/services/distributeddataservice/service/test/BUILD.gn
index 4e0f2fb2e102b500aa260e5e3d05d11ebbdcc72c..953d0da870cd18da6d41c0d7f3f8ee70cf7137c9 100644
--- a/services/distributeddataservice/service/test/BUILD.gn
+++ b/services/distributeddataservice/service/test/BUILD.gn
@@ -778,6 +778,72 @@ ohos_unittest("ObjectManagerTest") {
   ]
 }
 
+ohos_unittest("ObjectManagerMockTest") {
+  module_out_path = module_output_path
+  sources = [
+    "${data_service_path}/app/src/kvstore_meta_manager.cpp",
+    "${data_service_path}/service/common/common_types_utils.cpp",
+    "${data_service_path}/service/common/value_proxy.cpp",
+    "../object/src/object_asset_loader.cpp",
+    "../object/src/object_asset_machine.cpp",
+    "../object/src/object_callback_proxy.cpp",
+    "../object/src/object_data_listener.cpp",
+    "../object/src/object_dms_handler.cpp",
+    "../object/src/object_manager.cpp",
+    "../object/src/object_service_impl.cpp",
+    "../object/src/object_service_stub.cpp",
+    "../object/src/object_snapshot.cpp",
+    "../object/src/object_types_utils.cpp",
+    "mock/device_manager_adapter_mock.cpp",
+    "mock/kv_store_nb_delegate_mock.cpp",
+    "object_manager_mock_test.cpp",
+    "mock/meta_data_manager_mock.cpp",
+    "mock/device_matrix_mock.cpp",
+  ]
+
+  include_dirs = [
+    "${data_service_path}/adapter/include/utils",
+    "${data_service_path}/app/src",
+    "${data_service_path}/service/common",
+    "${data_service_path}/service/test/mock",
+  ]
+
+  configs = [ ":module_private_config" ]
+
+  external_deps = [
+    "access_token:libaccesstoken_sdk",
+    "access_token:libtoken_setproc",
+    "access_token:libtokenid_sdk",
+    "c_utils:utils",
+    "data_object:distributeddataobject_impl",
+    "data_object:data_object_inner",
+    "dataclassification:data_transit_mgr",
+    "dfs_service:cloudsync_asset_kit_inner",
+    "dfs_service:distributed_file_daemon_kit_inner",
+    "dmsfwk:distributed_sdk",
+    "googletest:gmock_main",
+    "hilog:libhilog",
+    "hisysevent:libhisysevent",
+    "ipc:ipc_core",
+    "cJSON:cjson",
+    "kv_store:distributeddata_inner",
+    "kv_store:distributeddata_mgr",
+    "kv_store:distributeddb",
+    "relational_store:native_rdb",
+    "safwk:system_ability_fwk",
+  ]
+
+  deps = [
+    "${data_service_path}/framework:distributeddatasvcfwk",
+    "${data_service_path}/service:distributeddatasvc",
+  ]
+
+  cflags = [
+    "-Dprivate=public",
+    "-Dprotected=public",
+  ]
+}
+
 ohos_unittest("ObjectSnapshotTest") {
   module_out_path = module_output_path
   sources = [
@@ -1975,6 +2041,7 @@ group("unittest") {
       ":ObjectDmsHandlerTest",
       ":ObjectManagerTest",
       ":ObjectSnapshotTest",
+      ":ObjectManagerMockTest",
     ]
   }
 
diff --git a/services/distributeddataservice/service/test/mock/BUILD.gn b/services/distributeddataservice/service/test/mock/BUILD.gn
index ce0a05278abb92ca72a0fa24e51ca940ae899dfd..36ead67ecc11b8da764d02f2f360b4d55dff564a 100644
--- a/services/distributeddataservice/service/test/mock/BUILD.gn
+++ b/services/distributeddataservice/service/test/mock/BUILD.gn
@@ -19,6 +19,7 @@ config("module_private_config") {
   include_dirs = [
     "${data_service_path}/adapter/include/communicator",
     "${data_service_path}/service/kvdb",
+    "${data_service_path}/service/matrix/include",
     "../../../framework/include/",
     "../../../service/rdb/",
     "./",
@@ -48,6 +49,7 @@ ohos_static_library("distributeddata_mock_static") {
     "network_delegate_mock.cpp",
     "screen_lock_mock.cpp",
     "user_delegate_mock.cpp",
+    "device_matrix_mock.cpp",
   ]
 
   deps = [ "${data_service_path}/framework:distributeddatasvcfwk" ]
diff --git a/services/distributeddataservice/service/test/mock/device_matrix_mock.cpp b/services/distributeddataservice/service/test/mock/device_matrix_mock.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..02a95da84b55d542830f9927e5ced06255bed03e
--- /dev/null
+++ b/services/distributeddataservice/service/test/mock/device_matrix_mock.cpp
@@ -0,0 +1,29 @@
+/*
+ * 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 "device_matrix_mock.h"
+
+namespace OHOS {
+namespace DistributedData {
+std::pair<bool, uint16_t> DeviceMatrix::GetRemoteMask(const std::string &device, DeviceMatrix::LevelType type)
+{
+    return BDeviceMatrix::deviceMatrix->GetRemoteMask(device, type);
+}
+
+std::pair<bool, uint16_t> DeviceMatrix::GetMask(const std::string &device, DeviceMatrix::LevelType type)
+{
+    return BDeviceMatrix::deviceMatrix->GetMask(device, type);
+}
+} // namespace DistributedData
+} // namespace OHOS
\ No newline at end of file
diff --git a/services/distributeddataservice/service/test/mock/device_matrix_mock.h b/services/distributeddataservice/service/test/mock/device_matrix_mock.h
new file mode 100644
index 0000000000000000000000000000000000000000..44159fa8edb192d395e590f34454e748e730c88d
--- /dev/null
+++ b/services/distributeddataservice/service/test/mock/device_matrix_mock.h
@@ -0,0 +1,37 @@
+/*
+ * 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_DEVICE_MATRIX_MOCK_H
+#define OHOS_DEVICE_MATRIX_MOCK_H
+
+#include <gmock/gmock.h>
+
+#include "device_matrix.h"
+
+namespace OHOS::DistributedData {
+class BDeviceMatrix {
+public:
+    virtual std::pair<bool, uint16_t> GetMask(const std::string &, DeviceMatrix::LevelType);
+    virtual std::pair<bool, uint16_t> GetRemoteMask(const std::string &, DeviceMatrix::LevelType);
+    BDeviceMatrix() = default;
+    virtual ~BDeviceMatrix() = default;
+    static inline std::shared_ptr<BDeviceMatrix> deviceMatrix = nullptr;
+};
+class DeviceMatrixMock : public BDeviceMatrix {
+public:
+    MOCK_METHOD((std::pair<bool, uint16_t>), GetMask, (const std::string &, DeviceMatrix::LevelType), (override));
+    MOCK_METHOD((std::pair<bool, uint16_t>), GetRemoteMask, (const std::string &, DeviceMatrix::LevelType), (override));
+};
+} // namespace OHOS::DistributedData
+#endif //OHOS_DEVICE_MATRIX_MOCK_H
diff --git a/services/distributeddataservice/service/test/mock/meta_data_manager_mock.cpp b/services/distributeddataservice/service/test/mock/meta_data_manager_mock.cpp
index 6af7ba916cee4235ee0bd83cbff1adea5c440a42..539defe377647a9f01e8dc2208b2183b5003222b 100644
--- a/services/distributeddataservice/service/test/mock/meta_data_manager_mock.cpp
+++ b/services/distributeddataservice/service/test/mock/meta_data_manager_mock.cpp
@@ -39,6 +39,12 @@ bool OHOS::DistributedData::MetaDataManager::LoadMeta(const std::string &key, Se
     return BMetaDataManager::metaDataManager->LoadMeta(key, value, isLocal);
 }
 
+bool OHOS::DistributedData::MetaDataManager::Sync(const std::vector<std::string> &devices,
+    MetaDataManager::OnComplete complete, bool wait)
+{
+    return BMetaDataManager::metaDataManager->Sync(devices, complete, wait);
+}
+
 template<>
 bool OHOS::DistributedData::MetaDataManager::LoadMeta(
     const std::string &prefix, std::vector<StoreMetaData> &values, bool isLocal)
diff --git a/services/distributeddataservice/service/test/mock/meta_data_manager_mock.h b/services/distributeddataservice/service/test/mock/meta_data_manager_mock.h
index 6db1bf93735376706386630ac2feb29a7db7a17b..42926ab9209b1728815318dd28165f6942192e01 100644
--- a/services/distributeddataservice/service/test/mock/meta_data_manager_mock.h
+++ b/services/distributeddataservice/service/test/mock/meta_data_manager_mock.h
@@ -26,6 +26,7 @@ namespace OHOS::DistributedData {
 class BMetaDataManager {
 public:
     virtual bool LoadMeta(const std::string &, Serializable &, bool) = 0;
+    virtual bool Sync(const std::vector<std::string> &, MetaDataManager::OnComplete, bool) = 0;
     BMetaDataManager() = default;
     virtual ~BMetaDataManager() = default;
     static inline std::shared_ptr<BMetaDataManager> metaDataManager = nullptr;
@@ -33,6 +34,7 @@ public:
 class MetaDataManagerMock : public BMetaDataManager {
 public:
     MOCK_METHOD(bool, LoadMeta, (const std::string &, Serializable &, bool), (override));
+    MOCK_METHOD(bool, Sync, (const std::vector<std::string> &, MetaDataManager::OnComplete, bool), (override));
 };
 
 template<class T> class BMetaData {
diff --git a/services/distributeddataservice/service/test/object_manager_mock_test.cpp b/services/distributeddataservice/service/test/object_manager_mock_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e6f04dda388657a3870a73f6c23318609f52fc88
--- /dev/null
+++ b/services/distributeddataservice/service/test/object_manager_mock_test.cpp
@@ -0,0 +1,287 @@
+/*
+* 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 "ObjectManagerMockTest"
+#include "object_manager.h"
+
+#include <gmock/gmock.h>
+#include "gtest/gtest.h"
+
+#include "device_matrix_mock.h"
+#include "mock/meta_data_manager_mock.h"
+#include "device_manager_adapter_mock.h"
+
+using namespace OHOS::DistributedObject;
+using namespace OHOS::DistributedData;
+using namespace testing::ext;
+using namespace testing;
+using DeviceInfo = OHOS::AppDistributedKv::DeviceInfo;
+using OnComplete = OHOS::DistributedData::MetaDataManager::OnComplete;
+
+namespace OHOS::Test {
+namespace DistributedDataTest {
+class ObjectManagerMockTest : public testing::Test {
+public:
+    static void SetUpTestCase(void)
+    {
+        metaDataManagerMock = std::make_shared<MetaDataManagerMock>();
+        BMetaDataManager::metaDataManager = metaDataManagerMock;
+        metaDataMock = std::make_shared<MetaDataMock<StoreMetaData>>();
+        BMetaData<StoreMetaData>::metaDataManager = metaDataMock;
+        devMgrAdapterMock = std::make_shared<DeviceManagerAdapterMock>();
+        BDeviceManagerAdapter::deviceManagerAdapter = devMgrAdapterMock;
+        deviceMatrixMock = std::make_shared<DeviceMatrixMock>();
+        BDeviceMatrix::deviceMatrix = deviceMatrixMock;
+    }
+    static void TearDownTestCase(void)
+    {
+        metaDataManagerMock = nullptr;
+        BMetaDataManager::metaDataManager = nullptr;
+        metaDataMock = nullptr;
+        BMetaData<StoreMetaData>::metaDataManager = nullptr;
+        devMgrAdapterMock = nullptr;
+        BDeviceManagerAdapter::deviceManagerAdapter = nullptr;
+        deviceMatrixMock = nullptr;
+        BDeviceMatrix::deviceMatrix = nullptr;
+    }
+
+    static inline std::shared_ptr<MetaDataManagerMock> metaDataManagerMock = nullptr;
+    static inline std::shared_ptr<MetaDataMock<StoreMetaData>> metaDataMock = nullptr;
+    static inline std::shared_ptr<DeviceManagerAdapterMock> devMgrAdapterMock = nullptr;
+    static inline std::shared_ptr<DeviceMatrixMock> deviceMatrixMock = nullptr;
+    void SetUp() {};
+    void TearDown() {};
+};
+
+/**
+ * @tc.name: IsNeedMetaSync001
+ * @tc.desc: Test IsNeedMetaSync
+ * @tc.type: FUNC
+ */
+HWTEST_F(ObjectManagerMockTest, IsNeedMetaSync001, 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<std::string> uuids = {"test_uuid"};
+
+    EXPECT_CALL(*metaDataManagerMock, LoadMeta(testing::_, testing::_, testing::_))
+        .WillOnce(testing::Return(false))
+        .WillOnce(testing::Return(false));
+    bool isNeedSync = manager->IsNeedMetaSync(meta, uuids);
+    EXPECT_EQ(isNeedSync, true);
+ 
+    EXPECT_CALL(*metaDataManagerMock, LoadMeta(testing::_, testing::_, testing::_))
+        .WillOnce(testing::Return(false))
+        .WillOnce(testing::Return(true));
+    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
+ * @tc.type: FUNC
+ */
+HWTEST_F(ObjectManagerMockTest, 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<std::string> 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
+ * @tc.type: FUNC
+ */
+HWTEST_F(ObjectManagerMockTest, 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<std::string> 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);
+}
+
+/**
+ * @tc.name: StoreMetaAndDoSync001
+ * @tc.desc: Test StoreMetaAndDoSync
+ * @tc.type: FUNC
+ */
+HWTEST_F(ObjectManagerMockTest, StoreMetaAndDoSync001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::string dstBundleName = "test_bundle";
+    std::string deviceId = "test_device";
+    std::string sessionId = "test_session";
+    sptr<IRemoteObject> impl = nullptr;
+    sptr<ObjectSaveCallbackProxy> proxy = new ObjectSaveCallbackProxy(impl);
+    
+    EXPECT_CALL(*devMgrAdapterMock, GetLocalDevice())
+        .WillOnce(Return(DeviceInfo{""}));
+    EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _))
+        .WillRepeatedly(Return(false));
+    
+    int32_t result = manager->StoreMetaAndDoSync(dstBundleName, deviceId, sessionId, proxy);
+    EXPECT_EQ(result, OBJECT_INNER_ERROR);
+}
+
+/**
+ * @tc.name: StoreMetaAndDoSync002
+ * @tc.desc: Test StoreMetaAndDoSync
+ * @tc.type: FUNC
+ */
+HWTEST_F(ObjectManagerMockTest, StoreMetaAndDoSync002, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::string dstBundleName = "test_bundle";
+    std::string deviceId = "test_device";
+    std::string sessionId = "test_session";
+    sptr<IRemoteObject> impl = nullptr;
+    sptr<ObjectSaveCallbackProxy> proxy = new ObjectSaveCallbackProxy(impl);
+    
+    DeviceInfo devInfo = { .uuid = "store2ID" };
+    EXPECT_CALL(*devMgrAdapterMock, GetLocalDevice())
+        .WillOnce(Return(devInfo));
+    
+    EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _))
+        .WillRepeatedly(Return(false));
+    
+    int32_t result = manager->StoreMetaAndDoSync(dstBundleName, deviceId, sessionId, proxy);
+    EXPECT_EQ(result, OBJECT_INNER_ERROR);
+}
+
+/**
+ * @tc.name: StoreMetaAndDoSync003
+ * @tc.desc: Test StoreMetaAndDoSync
+ * @tc.type: FUNC
+ */
+ HWTEST_F(ObjectManagerMockTest, StoreMetaAndDoSync003, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::string dstBundleName = "test_bundle";
+    std::string deviceId = "test_device";
+    std::string sessionId = "test_session";
+    sptr<IRemoteObject> impl = nullptr;
+    sptr<ObjectSaveCallbackProxy> proxy = new ObjectSaveCallbackProxy(impl);
+    
+    DeviceInfo devInfo = { .uuid = "store3ID" };
+    EXPECT_CALL(*devMgrAdapterMock, GetLocalDevice())
+        .WillRepeatedly(Return(devInfo));
+    
+    // IsNeedMetaSync true; sync false
+    EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _))
+        .WillOnce(Return(true))
+        .WillOnce(Return(false))
+        .WillOnce(Return(false));
+    EXPECT_CALL(*metaDataManagerMock, Sync(_, _, _))
+        .WillOnce(Return(false));
+    int32_t result = manager->StoreMetaAndDoSync(dstBundleName, deviceId, sessionId, proxy);
+    EXPECT_EQ(result, OBJECT_INNER_ERROR);
+
+    // IsNeedMetaSync false; sync false
+    EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _))
+        .WillOnce(Return(true))
+        .WillOnce(Return(true))
+        .WillOnce(Return(true));
+    EXPECT_CALL(*deviceMatrixMock, GetRemoteMask(_, _))
+        .WillOnce(Return(std::make_pair(true, 0)));
+    EXPECT_CALL(*deviceMatrixMock, GetMask(_, _))
+        .WillOnce(Return(std::make_pair(true, 0)));
+    EXPECT_CALL(*metaDataManagerMock, Sync(_, _, _))
+        .WillOnce(Return(false));
+    result = manager->StoreMetaAndDoSync(dstBundleName, deviceId, sessionId, proxy);
+    EXPECT_EQ(result, OBJECT_SUCCESS);
+
+    // IsNeedMetaSync false; sync true
+    EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _))
+        .WillOnce(Return(true))
+        .WillOnce(Return(true))
+        .WillOnce(Return(true));
+    EXPECT_CALL(*deviceMatrixMock, GetRemoteMask(_, _))
+        .WillOnce(Return(std::make_pair(true, 0)));
+    EXPECT_CALL(*deviceMatrixMock, GetMask(_, _))
+        .WillOnce(Return(std::make_pair(true, 0)));
+    EXPECT_CALL(*metaDataManagerMock, Sync(_, _, _))
+        .WillOnce(Return(true));
+    result = manager->StoreMetaAndDoSync(dstBundleName, deviceId, sessionId, proxy);
+    EXPECT_EQ(result, OBJECT_SUCCESS);
+}
+
+/**
+ * @tc.name: StoreMetaAndDoSync004
+ * @tc.desc: Test StoreMetaAndDoSync
+ * @tc.type: FUNC
+ */
+ HWTEST_F(ObjectManagerMockTest, StoreMetaAndDoSync004, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::string dstBundleName = "test_bundle";
+    std::string deviceId = "test_device";
+    std::string sessionId = "test_session";
+    sptr<IRemoteObject> impl = nullptr;
+    sptr<ObjectSaveCallbackProxy> proxy = new ObjectSaveCallbackProxy(impl);
+    
+    DeviceInfo devInfo = { .uuid = "store4ID" };
+    EXPECT_CALL(*devMgrAdapterMock, GetLocalDevice())
+        .WillOnce(Return(devInfo));
+
+    // IsNeedMetaSync true; sync true.
+    EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _))
+        .WillOnce(Return(true))
+        .WillOnce(Return(false))
+        .WillOnce(Return(false));
+    EXPECT_CALL(*metaDataManagerMock, Sync(_, _, _))
+        .WillOnce(Return(true));
+
+    int32_t result = manager->StoreMetaAndDoSync(dstBundleName, deviceId, sessionId, proxy);
+    EXPECT_EQ(result, OBJECT_SUCCESS);
+}
+}; // namespace OHOS::Test
+}
\ No newline at end of file