diff --git a/services/distributeddataservice/service/test/BUILD.gn b/services/distributeddataservice/service/test/BUILD.gn
index 90ee72eb35920ea872e8666ad12752d5c6d1da78..3b4fba4e09b23f16b76e1e31c27055043cce360f 100644
--- a/services/distributeddataservice/service/test/BUILD.gn
+++ b/services/distributeddataservice/service/test/BUILD.gn
@@ -1447,6 +1447,55 @@ ohos_unittest("QueryHelperUnitTest") {
   ]
 }
 
+ohos_unittest("AuthDelegateMockTest") {
+  module_out_path = module_output_path
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+
+  include_dirs = [
+    "${data_service_path}/adapter/include/communicator/",
+    "${data_service_path}/framework/include/",
+    "${data_service_path}/service/kvdb/",
+    "${data_service_path}/service/test/mock",
+  ]
+
+  sources = [
+    "auth_delegate_mock_test.cpp",
+    "mock/device_manager_adapter_mock.cpp",
+    "mock/user_delegate_mock.cpp",
+  ]
+
+  external_deps = [
+    "c_utils:utils",
+    "device_manager:devicemanagersdk",
+    "googletest:gmock_main",
+    "googletest:gtest_main",
+    "hilog:libhilog",
+    "json:nlohmann_json_static",
+    "kv_store:distributeddata_inner",
+  ]
+
+  deps = [
+    "${data_service_path}/framework:distributeddatasvcfwk",
+    "${data_service_path}/service:distributeddatasvc",
+  ]
+
+  cflags = [
+    "-Dprivate=public",
+    "-Dprotected=public",
+  ]
+
+  cflags_cc = cflags
+
+  defines = [
+    "TEST_ON_DEVICE",
+    "OPENSSL_SUPPRESS_DEPRECATED",
+  ]
+}
+
 ###############################################################################
 group("unittest") {
   testonly = true
@@ -1494,6 +1543,7 @@ group("unittest") {
 
   if (datamgr_service_kvdb) {
     deps += [
+      ":AuthDelegateMockTest",
       ":KVDBGeneralStoreAbnormalTest",
       ":KVDBGeneralStoreTest",
       ":KvdbServiceImplTest",
diff --git a/services/distributeddataservice/service/test/auth_delegate_mock_test.cpp b/services/distributeddataservice/service/test/auth_delegate_mock_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..970d45f0a55103b69b418ea2327593f3957666e9
--- /dev/null
+++ b/services/distributeddataservice/service/test/auth_delegate_mock_test.cpp
@@ -0,0 +1,183 @@
+/*
+ * 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 <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include "user_delegate_mock.h"
+#include "device_manager_adapter_mock.h"
+#include "auth_delegate.h"
+#include "types.h"
+
+namespace OHOS::DistributedData {
+using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter;
+using DistributedData::UserStatus;
+using AclParams = OHOS::AppDistributedKv::AclParams;
+using namespace testing;
+using namespace std;
+class AuthDelegateMockTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+public:
+    static inline shared_ptr<DeviceManagerAdapterMock> devMgrAdapterMock = nullptr;
+    static inline shared_ptr<UserDelegateMock> userDelegateMock = nullptr;
+    static inline AuthHandler *authHandler = nullptr;
+};
+
+void AuthDelegateMockTest::SetUpTestCase(void)
+{
+    authHandler = AuthDelegate::GetInstance();
+    devMgrAdapterMock = make_shared<DeviceManagerAdapterMock>();
+    BDeviceManagerAdapter::deviceManagerAdapter = devMgrAdapterMock;
+    userDelegateMock = make_shared<UserDelegateMock>();
+    BUserDelegate::userDelegate = userDelegateMock;
+}
+
+void AuthDelegateMockTest::TearDownTestCase(void)
+{
+    BDeviceManagerAdapter::deviceManagerAdapter = nullptr;
+    devMgrAdapterMock = nullptr;
+    userDelegateMock = nullptr;
+    BUserDelegate::userDelegate = nullptr;
+    authHandler = nullptr;
+}
+
+void AuthDelegateMockTest::SetUp(void)
+{}
+
+void AuthDelegateMockTest::TearDown(void)
+{}
+
+/**
+* @tc.name: CheckAccess001
+* @tc.desc: Check access.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: caozhijun
+*/
+HWTEST_F(AuthDelegateMockTest, CheckAccess001, testing::ext::TestSize.Level0)
+{
+    ASSERT_NE(authHandler, nullptr);
+    GTEST_LOG_(ERROR) << "CheckAccess001 enter in.";
+    int localUserId = 1;
+    int peerUserId = 1;
+    std::string peerDevId = "CheckAccess001";
+    AclParams aclParams;
+    UserStatus local;
+    local.id = localUserId;
+    local.isActive = true;
+    UserStatus remote;
+    remote.id = peerUserId;
+    remote.isActive = true;
+    std::vector<UserStatus> localUsers;
+    std::vector<UserStatus> peerUsers;
+    localUsers.push_back(local);
+    peerUsers.push_back(remote);
+    GTEST_LOG_(ERROR) << "CheckAccess001 second in.";
+    EXPECT_CALL(*userDelegateMock, GetLocalUserStatus()).WillOnce(Return(localUsers));
+    GTEST_LOG_(ERROR) << "CheckAccess001 third in.";
+    EXPECT_CALL(*userDelegateMock, GetRemoteUserStatus(_)).WillOnce(Return(peerUsers));
+    GTEST_LOG_(ERROR) << "CheckAccess001 fourth in.";
+    EXPECT_CALL(*devMgrAdapterMock, IsOHOSType(_)).WillOnce(Return(false));
+    GTEST_LOG_(ERROR) << "CheckAccess001 five in.";
+    auto result = authHandler->CheckAccess(localUserId, peerUserId, peerDevId, aclParams);
+    GTEST_LOG_(ERROR) << "CheckAccess001 six in.";
+    EXPECT_TRUE(result.first);
+}
+
+/**
+* @tc.name: CheckAccess002
+* @tc.desc: Check access.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: caozhijun
+*/
+HWTEST_F(AuthDelegateMockTest, CheckAccess002, testing::ext::TestSize.Level0)
+{
+    ASSERT_NE(authHandler, nullptr);
+    int localUserId = 1;
+    int peerUserId = 1;
+    std::string peerDevId = "CheckAccess002";
+    AclParams aclParams;
+    aclParams.authType = static_cast<int32_t>(DistributedKv::AuthType::DEFAULT);
+    UserStatus local;
+    local.id = localUserId;
+    local.isActive = true;
+    std::vector<UserStatus> localUsers = { local };
+    std::vector<UserStatus> peerUsers(localUsers);
+    EXPECT_CALL(*userDelegateMock, GetLocalUserStatus()).WillOnce(Return(localUsers));
+    EXPECT_CALL(*userDelegateMock, GetRemoteUserStatus(_)).WillOnce(Return(peerUsers));
+    EXPECT_CALL(*devMgrAdapterMock, IsOHOSType(_)).WillOnce(Return(true));
+    EXPECT_CALL(*devMgrAdapterMock, IsSameAccount(_, _)).WillOnce(Return(true));
+    auto result = authHandler->CheckAccess(localUserId, peerUserId, peerDevId, aclParams);
+    EXPECT_TRUE(result.first);
+
+    EXPECT_CALL(*userDelegateMock, GetLocalUserStatus()).WillOnce(Return(localUsers));
+    EXPECT_CALL(*userDelegateMock, GetRemoteUserStatus(_)).WillOnce(Return(peerUsers));
+    EXPECT_CALL(*devMgrAdapterMock, IsOHOSType(_)).WillOnce(Return(true));
+    EXPECT_CALL(*devMgrAdapterMock, IsSameAccount(_, _)).WillOnce(Return(false));
+    EXPECT_CALL(*devMgrAdapterMock, CheckAccessControl(_, _)).WillOnce(Return(true));
+    result = authHandler->CheckAccess(localUserId, peerUserId, peerDevId, aclParams);
+    EXPECT_TRUE(result.first);
+
+    aclParams.accCaller.bundleName = "com.AuthDelegateMockTest.app";
+    EXPECT_CALL(*userDelegateMock, GetLocalUserStatus()).WillOnce(Return(localUsers));
+    EXPECT_CALL(*userDelegateMock, GetRemoteUserStatus(_)).WillOnce(Return(peerUsers));
+    EXPECT_CALL(*devMgrAdapterMock, IsOHOSType(_)).WillOnce(Return(true));
+    EXPECT_CALL(*devMgrAdapterMock, IsSameAccount(_, _)).WillOnce(Return(false));
+    EXPECT_CALL(*devMgrAdapterMock, CheckAccessControl(_, _)).WillOnce(Return(false));
+    result = authHandler->CheckAccess(localUserId, peerUserId, peerDevId, aclParams);
+    EXPECT_FALSE(result.first);
+}
+
+/**
+* @tc.name: CheckAccess003
+* @tc.desc: Check access.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: caozhijun
+*/
+HWTEST_F(AuthDelegateMockTest, CheckAccess003, testing::ext::TestSize.Level0)
+{
+    ASSERT_NE(authHandler, nullptr);
+    int localUserId = 1;
+    int peerUserId = 1;
+    std::string peerDevId = "CheckAccess003";
+    AclParams aclParams;
+    aclParams.authType = static_cast<int32_t>(DistributedKv::AuthType::IDENTICAL_ACCOUNT);
+    UserStatus local;
+    local.id = localUserId;
+    local.isActive = true;
+    std::vector<UserStatus> localUsers = { local };
+    std::vector<UserStatus> peerUsers(localUsers);
+    EXPECT_CALL(*userDelegateMock, GetLocalUserStatus()).WillOnce(Return(localUsers));
+    EXPECT_CALL(*userDelegateMock, GetRemoteUserStatus(_)).WillOnce(Return(peerUsers));
+    EXPECT_CALL(*devMgrAdapterMock, IsOHOSType(_)).WillOnce(Return(true));
+    EXPECT_CALL(*devMgrAdapterMock, IsSameAccount(_, _)).WillOnce(Return(true));
+    auto result = authHandler->CheckAccess(localUserId, peerUserId, peerDevId, aclParams);
+    EXPECT_TRUE(result.first);
+
+    aclParams.authType += 1;
+    aclParams.accCaller.bundleName = "com.AuthDelegateTest.app";
+    EXPECT_CALL(*userDelegateMock, GetLocalUserStatus()).WillOnce(Return(localUsers));
+    EXPECT_CALL(*userDelegateMock, GetRemoteUserStatus(_)).WillOnce(Return(peerUsers));
+    EXPECT_CALL(*devMgrAdapterMock, IsOHOSType(_)).WillOnce(Return(true));
+    result = authHandler->CheckAccess(localUserId, peerUserId, peerDevId, aclParams);
+    EXPECT_FALSE(result.second);
+}
+}
\ No newline at end of file
diff --git a/services/distributeddataservice/service/test/mock/device_manager_adapter_mock.cpp b/services/distributeddataservice/service/test/mock/device_manager_adapter_mock.cpp
index 015bec1fe28658c22081425e53581a8a4447d9f2..3a1c0fd8c99a9f1b3b3789cfc9df8fca7eda19f5 100644
--- a/services/distributeddataservice/service/test/mock/device_manager_adapter_mock.cpp
+++ b/services/distributeddataservice/service/test/mock/device_manager_adapter_mock.cpp
@@ -41,4 +41,20 @@ bool OHOS::DistributedData::DeviceManagerAdapter::IsOHOSType(const std::string &
     }
     return BDeviceManagerAdapter::deviceManagerAdapter->IsOHOSType(id);
 }
+
+bool DeviceManagerAdapter::IsSameAccount(const AccessCaller &accCaller, const AccessCallee &accCallee)
+{
+    if (BDeviceManagerAdapter::deviceManagerAdapter == nullptr) {
+        return false;
+    }
+    return BDeviceManagerAdapter::deviceManagerAdapter->IsSameAccount(accCaller, accCallee);
+}
+
+bool DeviceManagerAdapter::CheckAccessControl(const AccessCaller &accCaller, const AccessCallee &accCallee)
+{
+    if (BDeviceManagerAdapter::deviceManagerAdapter == nullptr) {
+        return false;
+    }
+    return BDeviceManagerAdapter::deviceManagerAdapter->CheckAccessControl(accCaller, accCallee);
+}
 }
\ No newline at end of file
diff --git a/services/distributeddataservice/service/test/mock/device_manager_adapter_mock.h b/services/distributeddataservice/service/test/mock/device_manager_adapter_mock.h
index e302e40032c17dd6978b477f0c48077a4bc12722..40493b91b3b12fe72426e035e68391ee2258a87b 100644
--- a/services/distributeddataservice/service/test/mock/device_manager_adapter_mock.h
+++ b/services/distributeddataservice/service/test/mock/device_manager_adapter_mock.h
@@ -22,10 +22,14 @@
 namespace OHOS {
 namespace DistributedData {
 using namespace OHOS::AppDistributedKv;
+using AccessCaller = OHOS::AppDistributedKv::AccessCaller;
+using AccessCallee = OHOS::AppDistributedKv::AccessCallee;
 class BDeviceManagerAdapter {
 public:
     virtual bool IsOHOSType(const std::string &) = 0;
     virtual std::vector<std::string> ToUUID(std::vector<DeviceInfo>) = 0;
+    virtual bool IsSameAccount(const AccessCaller &, const AccessCallee &) = 0;
+    virtual bool CheckAccessControl(const AccessCaller &, const AccessCallee &) = 0;
     static inline std::shared_ptr<BDeviceManagerAdapter> deviceManagerAdapter = nullptr;
     BDeviceManagerAdapter() = default;
     virtual ~BDeviceManagerAdapter() = default;
@@ -35,6 +39,8 @@ class DeviceManagerAdapterMock : public BDeviceManagerAdapter {
 public:
     MOCK_METHOD(bool, IsOHOSType, (const std::string &));
     MOCK_METHOD(std::vector<std::string>, ToUUID, (std::vector<DeviceInfo>));
+    MOCK_METHOD(bool, IsSameAccount, (const AccessCaller &, const AccessCallee &));
+    MOCK_METHOD(bool, CheckAccessControl, (const AccessCaller &, const AccessCallee &));
 };
 
 } // namespace DistributedData
diff --git a/services/distributeddataservice/service/test/mock/user_delegate_mock.cpp b/services/distributeddataservice/service/test/mock/user_delegate_mock.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f13aafbd5d3d6f650dcbea5961c27f8c8789fc5c
--- /dev/null
+++ b/services/distributeddataservice/service/test/mock/user_delegate_mock.cpp
@@ -0,0 +1,104 @@
+/*
+ * 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 <set>
+#include <vector>
+#include "user_delegate_mock.h"
+
+namespace OHOS::DistributedData {
+using namespace OHOS::DistributedKv;
+using DistributedData::UserStatus;
+
+std::string GetLocalDeviceId()
+{
+    return "";
+}
+
+UserDelegate &UserDelegate::GetInstance()
+{
+    static UserDelegate instance;
+    return instance;
+}
+
+std::vector<UserStatus> UserDelegate::GetLocalUserStatus()
+{
+    if (BUserDelegate::userDelegate == nullptr) {
+        return {};
+    }
+    return BUserDelegate::userDelegate->GetLocalUserStatus();
+}
+
+std::vector<DistributedData::UserStatus> UserDelegate::GetRemoteUserStatus(const std::string &deviceId)
+{
+    if (BUserDelegate::userDelegate == nullptr) {
+        return {};
+    }
+    return BUserDelegate::userDelegate->GetRemoteUserStatus(deviceId);
+}
+
+std::set<std::string> UserDelegate::GetLocalUsers()
+{
+    return {};
+}
+
+std::vector<UserStatus> UserDelegate::GetUsers(const std::string &deviceId)
+{
+    return {};
+}
+
+void UserDelegate::DeleteUsers(const std::string &deviceId)
+{
+    return;
+}
+
+void UserDelegate::UpdateUsers(const std::string &deviceId, const std::vector<UserStatus> &userStatus)
+{
+    return;
+}
+
+bool UserDelegate::InitLocalUserMeta()
+{
+    return true;
+}
+
+void UserDelegate::Init(const std::shared_ptr<ExecutorPool> &executors)
+{
+    return;
+}
+
+ExecutorPool::Task UserDelegate::GeTask()
+{
+    return [this] {
+        return;
+    };
+}
+
+bool UserDelegate::NotifyUserEvent(const UserDelegate::UserEvent &userEvent)
+{
+    return true;
+}
+
+void UserDelegate::LocalUserObserver::OnAccountChanged(const AccountEventInfo &eventInfo, int32_t timeout)
+{
+    return;
+}
+
+UserDelegate::LocalUserObserver::LocalUserObserver(UserDelegate &userDelegate) : userDelegate_(userDelegate) {}
+
+std::string UserDelegate::LocalUserObserver::Name()
+{
+    return "user_delegate";
+}
+}
\ No newline at end of file
diff --git a/services/distributeddataservice/service/test/mock/user_delegate_mock.h b/services/distributeddataservice/service/test/mock/user_delegate_mock.h
new file mode 100644
index 0000000000000000000000000000000000000000..12ff3f5c62ce23da692141352ee8864d5414cb42
--- /dev/null
+++ b/services/distributeddataservice/service/test/mock/user_delegate_mock.h
@@ -0,0 +1,40 @@
+/*
+ * 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_DISTRIBUTEDDATA_SERVICE_TEST_USER_DELEGATE_MOCK_H
+#define OHOS_DISTRIBUTEDDATA_SERVICE_TEST_USER_DELEGATE_MOCK_H
+#include <vector>
+#include <gmock/gmock.h>
+#include "metadata/user_meta_data.h"
+
+#include "user_delegate.h"
+
+namespace OHOS::DistributedData {
+using DistributedData::UserStatus;
+class BUserDelegate {
+public:
+    virtual std::vector<UserStatus> GetLocalUserStatus() = 0;
+    virtual std::vector<UserStatus> GetRemoteUserStatus(const std::string &) = 0;
+    static inline std::shared_ptr<BUserDelegate> userDelegate = nullptr;
+    virtual ~BUserDelegate() = default;
+};
+
+class UserDelegateMock : public BUserDelegate {
+public:
+    MOCK_METHOD(std::vector<UserStatus>, GetLocalUserStatus, ());
+    MOCK_METHOD(std::vector<UserStatus>, GetRemoteUserStatus, (const std::string&));
+};
+}
+#endif // OHOS_DISTRIBUTEDDATA_SERVICE_TEST_USER_DELEGATE_MOCK_H
\ No newline at end of file