1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #define LOG_TAG "CloudDataTest"
16 #include <gtest/gtest.h>
17 #include <unistd.h>
18
19 #include "accesstoken_kit.h"
20 #include "account/account_delegate.h"
21 #include "bootstrap.h"
22 #include "checker_mock.h"
23 #include "cloud/change_event.h"
24 #include "cloud/cloud_event.h"
25 #include "cloud/cloud_last_sync_info.h"
26 #include "cloud/cloud_report.h"
27 #include "cloud/cloud_server.h"
28 #include "cloud/cloud_share_event.h"
29 #include "cloud/make_query_event.h"
30 #include "cloud/schema_meta.h"
31 #include "cloud_data_translate.h"
32 #include "cloud_service_impl.h"
33 #include "cloud_types.h"
34 #include "cloud_types_util.h"
35 #include "cloud_value_util.h"
36 #include "communicator/device_manager_adapter.h"
37 #include "device_matrix.h"
38 #include "eventcenter/event_center.h"
39 #include "feature/feature_system.h"
40 #include "ipc_skeleton.h"
41 #include "log_print.h"
42 #include "metadata/meta_data_manager.h"
43 #include "metadata/store_meta_data.h"
44 #include "metadata/store_meta_data_local.h"
45 #include "mock/db_store_mock.h"
46 #include "mock/general_store_mock.h"
47 #include "network_delegate.h"
48 #include "network_delegate_mock.h"
49 #include "rdb_query.h"
50 #include "rdb_service.h"
51 #include "rdb_service_impl.h"
52 #include "rdb_types.h"
53 #include "store/auto_cache.h"
54 #include "store/general_value.h"
55 #include "store/store_info.h"
56 #include "sync_manager.h"
57 #include "token_setproc.h"
58
59 using namespace testing::ext;
60 using namespace OHOS::DistributedData;
61 using namespace OHOS::Security::AccessToken;
62 using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter;
63 using Querykey = OHOS::CloudData::QueryKey;
64 using QueryLastResults = OHOS::CloudData::QueryLastResults;
65 using CloudSyncInfo = OHOS::CloudData::CloudSyncInfo;
66 using SharingCfm = OHOS::CloudData::SharingUtil::SharingCfm;
67 using Confirmation = OHOS::CloudData::Confirmation;
68 using CenterCode = OHOS::DistributedData::SharingCenter::SharingCode;
69 using Status = OHOS::CloudData::CloudService::Status;
70 using CloudSyncScene = OHOS::CloudData::CloudServiceImpl::CloudSyncScene;
71 using GenErr = OHOS::DistributedData::GeneralError;
72 uint64_t g_selfTokenID = 0;
73
AllocHapToken(const HapPolicyParams & policy)74 void AllocHapToken(const HapPolicyParams &policy)
75 {
76 HapInfoParams info = {
77 .userID = 100,
78 .bundleName = "test_cloud_bundleName",
79 .instIndex = 0,
80 .appIDDesc = "test_cloud_bundleName",
81 .isSystemApp = true
82 };
83 auto token = AccessTokenKit::AllocHapToken(info, policy);
84 SetSelfTokenID(token.tokenIDEx);
85 }
86
87 namespace OHOS::Test {
88 namespace DistributedDataTest {
89 static constexpr const int32_t EVT_USER = 102;
90 static constexpr const char *TEST_TRACE_ID = "123456789";
91 static constexpr const char *TEST_CLOUD_BUNDLE = "test_cloud_bundleName";
92 static constexpr const char *TEST_CLOUD_APPID = "test_cloud_appid";
93 static constexpr const char *TEST_CLOUD_STORE = "test_cloud_store";
94 static constexpr const char *TEST_CLOUD_STORE_1 = "test_cloud_store1";
95 static constexpr const char *TEST_CLOUD_ID = "test_cloud_id";
96 static constexpr const char *TEST_CLOUD_TABLE = "teat_cloud_table";
97 static constexpr const char *TEST_CLOUD_DATABASE_ALIAS_1 = "test_cloud_database_alias_1";
98 static constexpr const char *TEST_CLOUD_DATABASE_ALIAS_2 = "test_cloud_database_alias_2";
99 static constexpr const char *PERMISSION_CLOUDDATA_CONFIG = "ohos.permission.CLOUDDATA_CONFIG";
100 static constexpr const char *PERMISSION_GET_NETWORK_INFO = "ohos.permission.GET_NETWORK_INFO";
101 static constexpr const char *PERMISSION_DISTRIBUTED_DATASYNC = "ohos.permission.DISTRIBUTED_DATASYNC";
102 static constexpr const char *PERMISSION_ACCESS_SERVICE_DM = "ohos.permission.ACCESS_SERVICE_DM";
103 static constexpr const char *PERMISSION_MANAGE_LOCAL_ACCOUNTS = "ohos.permission.MANAGE_LOCAL_ACCOUNTS";
GetPermissionDef(const std::string & permission)104 PermissionDef GetPermissionDef(const std::string &permission)
105 {
106 PermissionDef def = { .permissionName = permission,
107 .bundleName = "test_cloud_bundleName",
108 .grantMode = 1,
109 .availableLevel = APL_SYSTEM_BASIC,
110 .label = "label",
111 .labelId = 1,
112 .description = "test_cloud_bundleName",
113 .descriptionId = 1 };
114 return def;
115 }
116
GetPermissionStateFull(const std::string & permission)117 PermissionStateFull GetPermissionStateFull(const std::string &permission)
118 {
119 PermissionStateFull stateFull = { .permissionName = permission,
120 .isGeneral = true,
121 .resDeviceID = { "local" },
122 .grantStatus = { PermissionState::PERMISSION_GRANTED },
123 .grantFlags = { 1 } };
124 return stateFull;
125 }
126 class CloudDataTest : public testing::Test {
127 public:
128 static void SetUpTestCase(void);
129 static void TearDownTestCase(void);
130 void SetUp();
131 void TearDown();
132
133 static SchemaMeta schemaMeta_;
134 static std::shared_ptr<CloudData::CloudServiceImpl> cloudServiceImpl_;
135
136 protected:
137 static void InitMetaData();
138 static void InitSchemaMeta();
139 static void InitCloudInfo();
140 static std::shared_ptr<DBStoreMock> dbStoreMock_;
141 static StoreMetaData metaData_;
142 static CloudInfo cloudInfo_;
143 static DistributedData::CheckerMock checker_;
144 static NetworkDelegateMock delegate_;
145 };
146
147 class CloudServerMock : public CloudServer {
148 public:
149 std::pair<int32_t, CloudInfo> GetServerInfo(int32_t userId, bool needSpaceInfo) override;
150 std::pair<int32_t, SchemaMeta> GetAppSchema(int32_t userId, const std::string &bundleName) override;
151 virtual ~CloudServerMock() = default;
152 static constexpr uint64_t REMAINSPACE = 1000;
153 static constexpr uint64_t TATALSPACE = 2000;
154 static constexpr int32_t INVALID_USER_ID = -1;
155 };
156
GetServerInfo(int32_t userId,bool needSpaceInfo)157 std::pair<int32_t, CloudInfo> CloudServerMock::GetServerInfo(int32_t userId, bool needSpaceInfo)
158 {
159 CloudInfo cloudInfo;
160 cloudInfo.user = userId;
161 cloudInfo.id = TEST_CLOUD_ID;
162 cloudInfo.remainSpace = REMAINSPACE;
163 cloudInfo.totalSpace = TATALSPACE;
164 cloudInfo.enableCloud = true;
165
166 CloudInfo::AppInfo appInfo;
167 appInfo.bundleName = TEST_CLOUD_BUNDLE;
168 appInfo.appId = TEST_CLOUD_APPID;
169 appInfo.version = 1;
170 appInfo.cloudSwitch = true;
171
172 cloudInfo.apps[TEST_CLOUD_BUNDLE] = std::move(appInfo);
173 return { E_OK, cloudInfo };
174 }
175
GetAppSchema(int32_t userId,const std::string & bundleName)176 std::pair<int32_t, SchemaMeta> CloudServerMock::GetAppSchema(int32_t userId, const std::string &bundleName)
177 {
178 if (userId == INVALID_USER_ID) {
179 return { E_ERROR, CloudDataTest::schemaMeta_ };
180 }
181
182 if (bundleName.empty()) {
183 SchemaMeta schemaMeta;
184 return { E_OK, schemaMeta };
185 }
186 return { E_OK, CloudDataTest::schemaMeta_ };
187 }
188
189 std::shared_ptr<DBStoreMock> CloudDataTest::dbStoreMock_ = std::make_shared<DBStoreMock>();
190 SchemaMeta CloudDataTest::schemaMeta_;
191 StoreMetaData CloudDataTest::metaData_;
192 CloudInfo CloudDataTest::cloudInfo_;
193 std::shared_ptr<CloudData::CloudServiceImpl> CloudDataTest::cloudServiceImpl_ =
194 std::make_shared<CloudData::CloudServiceImpl>();
195 DistributedData::CheckerMock CloudDataTest::checker_;
196 NetworkDelegateMock CloudDataTest::delegate_;
197
InitMetaData()198 void CloudDataTest::InitMetaData()
199 {
200 metaData_.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
201 metaData_.appId = TEST_CLOUD_APPID;
202 metaData_.bundleName = TEST_CLOUD_BUNDLE;
203 metaData_.tokenId = OHOS::IPCSkeleton::GetCallingTokenID();
204 metaData_.user = std::to_string(AccountDelegate::GetInstance()->GetUserByToken(metaData_.tokenId));
205 metaData_.area = OHOS::DistributedKv::EL1;
206 metaData_.instanceId = 0;
207 metaData_.isAutoSync = true;
208 metaData_.storeType = DistributedRdb::RDB_DEVICE_COLLABORATION;
209 metaData_.storeId = TEST_CLOUD_STORE;
210 PolicyValue value;
211 value.type = OHOS::DistributedKv::PolicyType::IMMEDIATE_SYNC_ON_ONLINE;
212 }
213
InitSchemaMeta()214 void CloudDataTest::InitSchemaMeta()
215 {
216 SchemaMeta::Field field1;
217 field1.colName = "test_cloud_field_name1";
218 field1.alias = "test_cloud_field_alias1";
219 SchemaMeta::Field field2;
220 field2.colName = "test_cloud_field_name2";
221 field2.alias = "test_cloud_field_alias2";
222
223 SchemaMeta::Table table;
224 table.name = "test_cloud_table_name";
225 table.alias = "test_cloud_table_alias";
226 table.fields.emplace_back(field1);
227 table.fields.emplace_back(field2);
228
229 SchemaMeta::Database database;
230 database.name = TEST_CLOUD_STORE;
231 database.alias = TEST_CLOUD_DATABASE_ALIAS_1;
232 database.tables.emplace_back(table);
233
234 schemaMeta_.version = 1;
235 schemaMeta_.bundleName = TEST_CLOUD_BUNDLE;
236 schemaMeta_.databases.emplace_back(database);
237 database.alias = TEST_CLOUD_DATABASE_ALIAS_2;
238 schemaMeta_.databases.emplace_back(database);
239 }
240
InitCloudInfo()241 void CloudDataTest::InitCloudInfo()
242 {
243 cloudInfo_.user = AccountDelegate::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID());
244 cloudInfo_.id = TEST_CLOUD_ID;
245 cloudInfo_.enableCloud = true;
246
247 CloudInfo::AppInfo appInfo;
248 appInfo.bundleName = TEST_CLOUD_BUNDLE;
249 appInfo.appId = TEST_CLOUD_APPID;
250 appInfo.version = 1;
251 appInfo.cloudSwitch = true;
252
253 cloudInfo_.apps[TEST_CLOUD_BUNDLE] = std::move(appInfo);
254 }
255
SetUpTestCase(void)256 void CloudDataTest::SetUpTestCase(void)
257 {
258 MetaDataManager::GetInstance().Initialize(dbStoreMock_, nullptr, "");
259 MetaDataManager::GetInstance().SetSyncer([](const auto &, auto) {
260 DeviceMatrix::GetInstance().OnChanged(DeviceMatrix::META_STORE_MASK);
261 });
262
263 auto cloudServerMock = new CloudServerMock();
264 CloudServer::RegisterCloudInstance(cloudServerMock);
265 HapPolicyParams policy = { .apl = APL_SYSTEM_BASIC,
266 .domain = "test.domain",
267 .permList = { GetPermissionDef(PERMISSION_CLOUDDATA_CONFIG), GetPermissionDef(PERMISSION_GET_NETWORK_INFO),
268 GetPermissionDef(PERMISSION_DISTRIBUTED_DATASYNC), GetPermissionDef(PERMISSION_ACCESS_SERVICE_DM),
269 GetPermissionDef(PERMISSION_MANAGE_LOCAL_ACCOUNTS) },
270 .permStateList = { GetPermissionStateFull(PERMISSION_CLOUDDATA_CONFIG),
271 GetPermissionStateFull(PERMISSION_GET_NETWORK_INFO),
272 GetPermissionStateFull(PERMISSION_DISTRIBUTED_DATASYNC),
273 GetPermissionStateFull(PERMISSION_ACCESS_SERVICE_DM),
274 GetPermissionStateFull(PERMISSION_MANAGE_LOCAL_ACCOUNTS)} };
275 g_selfTokenID = GetSelfTokenID();
276 AllocHapToken(policy);
277 size_t max = 12;
278 size_t min = 5;
279
280 auto executor = std::make_shared<ExecutorPool>(max, min);
281 cloudServiceImpl_->OnBind(
282 { "CloudDataTest", static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID()), std::move(executor) });
283 Bootstrap::GetInstance().LoadCheckers();
284 auto dmExecutor = std::make_shared<ExecutorPool>(max, min);
285 DeviceManagerAdapter::GetInstance().Init(dmExecutor);
286 NetworkDelegate::RegisterNetworkInstance(&delegate_);
287 InitCloudInfo();
288 InitMetaData();
289 InitSchemaMeta();
290 }
291
TearDownTestCase()292 void CloudDataTest::TearDownTestCase()
293 {
294 SetSelfTokenID(g_selfTokenID);
295 }
296
SetUp()297 void CloudDataTest::SetUp()
298 {
299 MetaDataManager::GetInstance().SaveMeta(cloudInfo_.GetKey(), cloudInfo_, true);
300 MetaDataManager::GetInstance().SaveMeta(metaData_.GetKey(), metaData_, true);
301 MetaDataManager::GetInstance().SaveMeta(cloudInfo_.GetSchemaKey(TEST_CLOUD_BUNDLE), schemaMeta_, true);
302 }
303
TearDown()304 void CloudDataTest::TearDown()
305 {
306 EventCenter::GetInstance().Unsubscribe(CloudEvent::LOCAL_CHANGE);
307 MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
308 MetaDataManager::GetInstance().DelMeta(metaData_.GetKey(), true);
309 MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetSchemaKey(TEST_CLOUD_BUNDLE), true);
310 }
311
312 /**
313 * @tc.name: GetSchema
314 * @tc.desc: GetSchema from cloud when no schema in meta.
315 * @tc.type: FUNC
316 * @tc.require:
317 * @tc.author: ht
318 */
319 HWTEST_F(CloudDataTest, GetSchema, TestSize.Level0)
320 {
321 auto cloudServerMock = std::make_shared<CloudServerMock>();
322 auto user = AccountDelegate::GetInstance()->GetUserByToken(OHOS::IPCSkeleton::GetCallingTokenID());
323 auto [status, cloudInfo] = cloudServerMock->GetServerInfo(user, true);
324 ASSERT_TRUE(MetaDataManager::GetInstance().DelMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE), true));
325 SchemaMeta schemaMeta;
326 ASSERT_FALSE(MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE), schemaMeta, true));
327 StoreInfo storeInfo{ OHOS::IPCSkeleton::GetCallingTokenID(), TEST_CLOUD_BUNDLE, TEST_CLOUD_STORE, 0 };
328 auto event = std::make_unique<CloudEvent>(CloudEvent::GET_SCHEMA, storeInfo);
329 EventCenter::GetInstance().PostEvent(std::move(event));
330 auto ret = MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE), schemaMeta, true);
331 ASSERT_TRUE(ret);
332 }
333
334 /**
335 * @tc.name: QueryStatistics
336 * @tc.desc: The query interface failed because cloudInfo could not be found from the metadata.
337 * @tc.type: FUNC
338 * @tc.require:
339 */
340 HWTEST_F(CloudDataTest, QueryStatistics001, TestSize.Level0)
341 {
342 // prepare MetaDta
343 MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
344
345 auto [status, result] = cloudServiceImpl_->QueryStatistics(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, "");
346 EXPECT_EQ(status, CloudData::CloudService::ERROR);
347 EXPECT_TRUE(result.empty());
348 }
349
350 /**
351 * @tc.name: QueryStatistics
352 * @tc.desc: The query interface failed because SchemaMeta could not be found from the metadata.
353 * @tc.type: FUNC
354 * @tc.require:
355 */
356 HWTEST_F(CloudDataTest, QueryStatistics002, TestSize.Level0)
357 {
358 // prepare MetaDta
359 MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetSchemaKey(TEST_CLOUD_BUNDLE), true);
360 MetaDataManager::GetInstance().SaveMeta(cloudInfo_.GetKey(), cloudInfo_, true);
361
362 auto [status, result] = cloudServiceImpl_->QueryStatistics("", "", "");
363 EXPECT_EQ(status, CloudData::CloudService::ERROR);
364 EXPECT_TRUE(result.empty());
365 std::tie(status, result) = cloudServiceImpl_->QueryStatistics(TEST_CLOUD_ID, "", "");
366 EXPECT_EQ(status, CloudData::CloudService::ERROR);
367 EXPECT_TRUE(result.empty());
368 std::tie(status, result) = cloudServiceImpl_->QueryStatistics(TEST_CLOUD_ID, TEST_CLOUD_STORE, "");
369 EXPECT_EQ(status, CloudData::CloudService::ERROR);
370 EXPECT_TRUE(result.empty());
371 std::tie(status, result) = cloudServiceImpl_->QueryStatistics(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, "");
372 EXPECT_EQ(status, CloudData::CloudService::ERROR);
373 EXPECT_TRUE(result.empty());
374 }
375
376 /**
377 * @tc.name: QueryStatistics
378 * @tc.desc: Query the statistics of cloud records in a specified database.
379 * @tc.type: FUNC
380 * @tc.require:
381 */
382 HWTEST_F(CloudDataTest, QueryStatistics003, TestSize.Level0)
383 {
384 // Construct the statisticInfo data
__anon572e501f0202(const StoreMetaData &metaData) 385 auto creator = [](const StoreMetaData &metaData) -> GeneralStore* {
386 auto store = new (std::nothrow) GeneralStoreMock();
387 if (store != nullptr) {
388 std::map<std::string, Value> entry = { { "inserted", 1 }, { "updated", 2 }, { "normal", 3 } };
389 store->MakeCursor(entry);
390 store->SetEqualIdentifier("", "");
391 }
392 return store;
393 };
394 AutoCache::GetInstance().RegCreator(DistributedRdb::RDB_DEVICE_COLLABORATION, creator);
395
396 auto [status, result] =
397 cloudServiceImpl_->QueryStatistics(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
398 ASSERT_EQ(status, CloudData::CloudService::SUCCESS);
399 ASSERT_EQ(result.size(), 1);
400 for (const auto &it : result) {
401 ASSERT_EQ(it.first, TEST_CLOUD_DATABASE_ALIAS_1);
402 auto statisticInfos = it.second;
403 ASSERT_FALSE(statisticInfos.empty());
404 for (const auto &info : statisticInfos) {
405 EXPECT_EQ(info.inserted, 1);
406 EXPECT_EQ(info.updated, 2);
407 EXPECT_EQ(info.normal, 3);
408 }
409 }
410 }
411
412 /**
413 * @tc.name: QueryStatistics
414 * @tc.desc: Query the statistics of all local database cloud records.
415 * @tc.type: FUNC
416 * @tc.require:
417 */
418 HWTEST_F(CloudDataTest, QueryStatistics004, TestSize.Level0)
419 {
420 // Construct the statisticInfo data
__anon572e501f0302(const StoreMetaData &metaData) 421 auto creator = [](const StoreMetaData &metaData) -> GeneralStore* {
422 auto store = new (std::nothrow) GeneralStoreMock();
423 if (store != nullptr) {
424 std::map<std::string, Value> entry = { { "inserted", 1 }, { "updated", 2 }, { "normal", 3 } };
425 store->MakeCursor(entry);
426 }
427 return store;
428 };
429 AutoCache::GetInstance().RegCreator(DistributedRdb::RDB_DEVICE_COLLABORATION, creator);
430
431 auto [status, result] = cloudServiceImpl_->QueryStatistics(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, "");
432 ASSERT_EQ(status, CloudData::CloudService::SUCCESS);
433 ASSERT_EQ(result.size(), 2);
434 for (const auto &it : result) {
435 auto statisticInfos = it.second;
436 ASSERT_FALSE(statisticInfos.empty());
437 for (const auto &info : statisticInfos) {
438 EXPECT_EQ(info.inserted, 1);
439 EXPECT_EQ(info.updated, 2);
440 EXPECT_EQ(info.normal, 3);
441 }
442 }
443 }
444
445 /**
446 * @tc.name: QueryLastSyncInfo001
447 * @tc.desc: The query last sync info interface failed because account is false.
448 * @tc.type: FUNC
449 * @tc.require:
450 */
451 HWTEST_F(CloudDataTest, QueryLastSyncInfo001, TestSize.Level0)
452 {
453 auto [status, result] =
454 cloudServiceImpl_->QueryLastSyncInfo("accountId", TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
455 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
456 EXPECT_TRUE(result.empty());
457 }
458
459 /**
460 * @tc.name: QueryLastSyncInfo002
461 * @tc.desc: The query last sync info interface failed because bundleName is false.
462 * @tc.type: FUNC
463 * @tc.require:
464 */
465 HWTEST_F(CloudDataTest, QueryLastSyncInfo002, TestSize.Level0)
466 {
467 auto [status, result] =
468 cloudServiceImpl_->QueryLastSyncInfo(TEST_CLOUD_ID, "bundleName", TEST_CLOUD_DATABASE_ALIAS_1);
469 EXPECT_EQ(status, CloudData::CloudService::Status::INVALID_ARGUMENT);
470 EXPECT_TRUE(result.empty());
471 }
472
473 /**
474 * @tc.name: QueryLastSyncInfo003
475 * @tc.desc: The query last sync info interface failed because storeId is false.
476 * @tc.type: FUNC
477 * @tc.require:
478 */
479 HWTEST_F(CloudDataTest, QueryLastSyncInfo003, TestSize.Level0)
480 {
481 auto [status, result] = cloudServiceImpl_->QueryLastSyncInfo(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, "storeId");
482 EXPECT_EQ(status, CloudData::CloudService::INVALID_ARGUMENT);
483 EXPECT_TRUE(result.empty());
484 }
485
486 /**
487 * @tc.name: QueryLastSyncInfo004
488 * @tc.desc: The query last sync info interface
489 * @tc.type: FUNC
490 * @tc.require:
491 */
492 HWTEST_F(CloudDataTest, QueryLastSyncInfo004, TestSize.Level0)
493 {
494 auto ret = cloudServiceImpl_->DisableCloud(TEST_CLOUD_ID);
495 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
496 cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID);
497
498 sleep(1);
499
500 auto [status, result] =
501 cloudServiceImpl_->QueryLastSyncInfo(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
502 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
503 EXPECT_TRUE(!result.empty());
504 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].code == E_BLOCKED_BY_NETWORK_STRATEGY);
505 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].startTime != 0);
506 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].finishTime != 0);
507 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].syncStatus == 1);
508 }
509
510 /**
511 * @tc.name: QueryLastSyncInfo005
512 * @tc.desc: The query last sync info interface
513 * @tc.type: FUNC
514 * @tc.require:
515 */
516 HWTEST_F(CloudDataTest, QueryLastSyncInfo005, TestSize.Level0)
517 {
518 std::map<std::string, int32_t> switches;
519 switches.emplace(TEST_CLOUD_ID, true);
520 CloudInfo info;
521 MetaDataManager::GetInstance().LoadMeta(cloudInfo_.GetKey(), info, true);
522 info.apps[TEST_CLOUD_BUNDLE].cloudSwitch = false;
523 MetaDataManager::GetInstance().SaveMeta(info.GetKey(), info, true);
524 cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID);
525 sleep(1);
526
527 auto [status, result] =
528 cloudServiceImpl_->QueryLastSyncInfo(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
529 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
530 EXPECT_TRUE(!result.empty());
531 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].code == E_BLOCKED_BY_NETWORK_STRATEGY);
532 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].startTime != 0);
533 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].finishTime != 0);
534 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].syncStatus == 1);
535 }
536
537 /**
538 * @tc.name: QueryLastSyncInfo006
539 * @tc.desc: The query last sync info interface
540 * @tc.type: FUNC
541 * @tc.require:
542 */
543 HWTEST_F(CloudDataTest, QueryLastSyncInfo006, TestSize.Level0)
544 {
545 MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetSchemaKey(TEST_CLOUD_BUNDLE), true);
546 auto [status, result] =
547 cloudServiceImpl_->QueryLastSyncInfo(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
548 EXPECT_EQ(status, CloudData::CloudService::ERROR);
549 EXPECT_TRUE(result.empty());
550 SchemaMeta meta;
551 meta.bundleName = "test";
552 MetaDataManager::GetInstance().SaveMeta(cloudInfo_.GetSchemaKey(TEST_CLOUD_BUNDLE), meta, true);
553 std::tie(status, result) =
554 cloudServiceImpl_->QueryLastSyncInfo(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
555 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
556 EXPECT_TRUE(result.empty());
557 }
558
559 /**
560 * @tc.name: QueryLastSyncInfo007
561 * @tc.desc: The query last sync info interface
562 * @tc.type: FUNC
563 * @tc.require:
564 */
565 HWTEST_F(CloudDataTest, QueryLastSyncInfo007, TestSize.Level0)
566 {
567 int32_t user = 100;
568 int64_t startTime = 123456789;
569 int64_t finishTime = 123456799;
570 CloudLastSyncInfo lastSyncInfo;
571 lastSyncInfo.id = TEST_CLOUD_ID;
572 lastSyncInfo.storeId = TEST_CLOUD_DATABASE_ALIAS_1;
573 lastSyncInfo.startTime = startTime;
574 lastSyncInfo.finishTime = finishTime;
575 lastSyncInfo.syncStatus = 1;
576 MetaDataManager::GetInstance().SaveMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
577 TEST_CLOUD_DATABASE_ALIAS_1), lastSyncInfo, true);
578
579 std::vector<CloudLastSyncInfo> lastSyncInfos;
580 MetaDataManager::GetInstance().LoadMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
581 TEST_CLOUD_DATABASE_ALIAS_1), lastSyncInfos, true);
582 EXPECT_TRUE(!lastSyncInfos.empty());
583
584 CloudData::SyncManager sync;
585 auto [status, result] = sync.QueryLastSyncInfo({ { user, TEST_CLOUD_ID, TEST_CLOUD_BUNDLE,
586 TEST_CLOUD_DATABASE_ALIAS_1 } });
587 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
588 EXPECT_TRUE(!result.empty());
589 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].code == -1);
590 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].startTime == startTime);
591 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].finishTime == finishTime);
592 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].syncStatus == 1);
593 }
594
595 /**
596 * @tc.name: QueryLastSyncInfo008
597 * @tc.desc: The query last sync info interface
598 * @tc.type: FUNC
599 * @tc.require:
600 */
601 HWTEST_F(CloudDataTest, QueryLastSyncInfo008, TestSize.Level0)
602 {
603 int32_t user = 100;
604 int64_t startTime = 123456789;
605 int64_t finishTime = 123456799;
606 CloudLastSyncInfo lastSyncInfo;
607 lastSyncInfo.id = TEST_CLOUD_ID;
608 lastSyncInfo.storeId = TEST_CLOUD_DATABASE_ALIAS_1;
609 lastSyncInfo.startTime = startTime;
610 lastSyncInfo.finishTime = finishTime;
611 lastSyncInfo.syncStatus = 1;
612 lastSyncInfo.code = 0;
613 MetaDataManager::GetInstance().SaveMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
614 TEST_CLOUD_DATABASE_ALIAS_1), lastSyncInfo, true);
615 CloudLastSyncInfo lastSyncInfo1;
616 lastSyncInfo1.id = TEST_CLOUD_ID;
617 lastSyncInfo1.storeId = TEST_CLOUD_DATABASE_ALIAS_2;
618 lastSyncInfo1.startTime = startTime;
619 lastSyncInfo1.finishTime = finishTime;
620 lastSyncInfo1.syncStatus = 1;
621 lastSyncInfo1.code = 0;
622 MetaDataManager::GetInstance().SaveMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
623 TEST_CLOUD_DATABASE_ALIAS_2), lastSyncInfo1, true);
624
625 std::vector<CloudLastSyncInfo> lastSyncInfos;
626 MetaDataManager::GetInstance().LoadMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
627 ""), lastSyncInfos, true);
628 EXPECT_TRUE(!lastSyncInfos.empty());
629
630 CloudData::SyncManager sync;
631 auto [status, result] = sync.QueryLastSyncInfo({ { user, TEST_CLOUD_ID, TEST_CLOUD_BUNDLE,
632 TEST_CLOUD_DATABASE_ALIAS_1 }, { user, TEST_CLOUD_ID, TEST_CLOUD_BUNDLE,
633 TEST_CLOUD_DATABASE_ALIAS_2} });
634
635 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
636 EXPECT_TRUE(result.size() == 2);
637 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].code == 0);
638 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].startTime == startTime);
639 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].finishTime == finishTime);
640 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].syncStatus == 1);
641
642 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_2].code == 0);
643 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_2].startTime == startTime);
644 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_2].finishTime == finishTime);
645 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_2].syncStatus == 1);
646 }
647
648 /**
649 * @tc.name: QueryLastSyncInfo009
650 * @tc.desc: The query last sync info interface failed when schema is invalid.
651 * @tc.type: FUNC
652 * @tc.require:
653 */
654 HWTEST_F(CloudDataTest, QueryLastSyncInfo009, TestSize.Level0)
655 {
656 int32_t user = 100;
657 int64_t startTime = 123456789;
658 int64_t finishTime = 123456799;
659 CloudLastSyncInfo lastSyncInfo;
660 lastSyncInfo.id = TEST_CLOUD_ID;
661 lastSyncInfo.storeId = TEST_CLOUD_DATABASE_ALIAS_1;
662 lastSyncInfo.startTime = startTime;
663 lastSyncInfo.finishTime = finishTime;
664 lastSyncInfo.syncStatus = 1;
665 lastSyncInfo.code = 0;
666 MetaDataManager::GetInstance().SaveMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
667 TEST_CLOUD_DATABASE_ALIAS_1), lastSyncInfo, true);
668 CloudLastSyncInfo lastSyncInfo1;
669 lastSyncInfo1.id = TEST_CLOUD_ID;
670 lastSyncInfo1.storeId = TEST_CLOUD_DATABASE_ALIAS_2;
671 lastSyncInfo1.startTime = startTime;
672 lastSyncInfo1.finishTime = finishTime;
673 lastSyncInfo1.syncStatus = 1;
674 lastSyncInfo1.code = 0;
675 MetaDataManager::GetInstance().SaveMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
676 TEST_CLOUD_DATABASE_ALIAS_2), lastSyncInfo1, true);
677
678 std::vector<CloudLastSyncInfo> lastSyncInfos;
679 MetaDataManager::GetInstance().LoadMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE, ""),
680 lastSyncInfos, true);
681 EXPECT_TRUE(!lastSyncInfos.empty());
682
683 CloudData::SyncManager sync;
684 auto [status, result] = sync.QueryLastSyncInfo({ { user, TEST_CLOUD_ID, TEST_CLOUD_BUNDLE,
685 TEST_CLOUD_DATABASE_ALIAS_2} });
686 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
687 EXPECT_TRUE(result.size() == 1);
688 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_2].code == 0);
689 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_2].startTime == startTime);
690 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_2].finishTime == finishTime);
691 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_2].syncStatus == 1);
692 }
693
694 /**
695 * @tc.name: QueryLastSyncInfo010
696 * @tc.desc: The query last sync info interface failed
697 * @tc.type: FUNC
698 * @tc.require:
699 */
700 HWTEST_F(CloudDataTest, QueryLastSyncInfo010, TestSize.Level0)
701 {
702 int32_t user = 100;
703 int64_t startTime = 123456789;
704 int64_t finishTime = 123456799;
705 CloudLastSyncInfo lastSyncInfo;
706 lastSyncInfo.id = TEST_CLOUD_ID;
707 lastSyncInfo.storeId = TEST_CLOUD_DATABASE_ALIAS_1;
708 lastSyncInfo.startTime = startTime;
709 lastSyncInfo.finishTime = finishTime;
710 lastSyncInfo.syncStatus = 1;
711 lastSyncInfo.code = 0;
712 MetaDataManager::GetInstance().SaveMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
713 TEST_CLOUD_DATABASE_ALIAS_1), lastSyncInfo, true);
714 CloudLastSyncInfo lastSyncInfo1;
715 lastSyncInfo1.id = TEST_CLOUD_ID;
716 lastSyncInfo1.storeId = TEST_CLOUD_DATABASE_ALIAS_2;
717 lastSyncInfo1.startTime = startTime;
718 lastSyncInfo1.finishTime = finishTime;
719 lastSyncInfo1.syncStatus = 1;
720 lastSyncInfo1.code = 0;
721 MetaDataManager::GetInstance().SaveMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
722 TEST_CLOUD_DATABASE_ALIAS_2), lastSyncInfo1, true);
723
724 CloudData::SyncManager sync;
725 CloudData::SyncManager::SyncInfo info(user, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
726 auto [status, result] = sync.QueryLastSyncInfo({ { user, TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, "1234"} });
727 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
728 EXPECT_TRUE(result.empty());
729 }
730
731 /**
732 * @tc.name: QueryLastSyncInfo011
733 * @tc.desc: The query last sync info interface
734 * @tc.type: FUNC
735 * @tc.require:
736 */
737 HWTEST_F(CloudDataTest, QueryLastSyncInfo011, TestSize.Level0)
738 {
739 schemaMeta_.databases[1].name = TEST_CLOUD_STORE_1;
740 MetaDataManager::GetInstance().SaveMeta(cloudInfo_.GetSchemaKey(TEST_CLOUD_BUNDLE), schemaMeta_, true);
741 int32_t user = 100;
742 CloudData::SyncManager sync;
743 CloudData::SyncManager::SyncInfo info(user, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
744 info.syncId_ = 0;
745 CloudInfo cloud;
746 cloud.user = info.user_;
747 auto cloudSyncInfos = sync.GetCloudSyncInfo(info, cloud);
748 sync.UpdateStartSyncInfo(cloudSyncInfos);
749 auto [status, result] = sync.QueryLastSyncInfo({ { user, TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_STORE },
750 { user, TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_STORE_1} });
751 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
752 EXPECT_TRUE(result.size() == 2);
753 EXPECT_TRUE(result[TEST_CLOUD_STORE].code == 0);
754 EXPECT_TRUE(result[TEST_CLOUD_STORE].startTime != 0);
755 EXPECT_TRUE(result[TEST_CLOUD_STORE].finishTime == 0);
756 EXPECT_TRUE(result[TEST_CLOUD_STORE].syncStatus == 0);
757
758 EXPECT_TRUE(result[TEST_CLOUD_STORE_1].code == 0);
759 EXPECT_TRUE(result[TEST_CLOUD_STORE_1].startTime != 0);
760 EXPECT_TRUE(result[TEST_CLOUD_STORE_1].finishTime == 0);
761 EXPECT_TRUE(result[TEST_CLOUD_STORE_1].syncStatus == 0);
762 }
763
764 /**
765 * @tc.name: QueryLastSyncInfo012
766 * @tc.desc: The query last sync info interface failed.
767 * @tc.type: FUNC
768 * @tc.require:
769 */
770 HWTEST_F(CloudDataTest, QueryLastSyncInfo012, TestSize.Level0)
771 {
772 int32_t user = 100;
773 int64_t startTime = 123456789;
774 int64_t finishTime = 123456799;
775 CloudLastSyncInfo lastSyncInfo;
776 lastSyncInfo.id = TEST_CLOUD_ID;
777 lastSyncInfo.storeId = TEST_CLOUD_DATABASE_ALIAS_1;
778 lastSyncInfo.startTime = startTime;
779 lastSyncInfo.finishTime = finishTime;
780 lastSyncInfo.syncStatus = 1;
781 MetaDataManager::GetInstance().SaveMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
782 TEST_CLOUD_DATABASE_ALIAS_1), lastSyncInfo, true);
783
784 std::vector<CloudLastSyncInfo> lastSyncInfos;
785 MetaDataManager::GetInstance().LoadMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
786 TEST_CLOUD_DATABASE_ALIAS_1), lastSyncInfos, true);
787 EXPECT_TRUE(!lastSyncInfos.empty());
788
789 CloudData::SyncManager sync;
790 CloudData::SyncManager::SyncInfo info(user, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
791 auto [status, result] = sync.QueryLastSyncInfo({ { user, TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, "1234"} });
792 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
793 EXPECT_TRUE(result.empty());
794 }
795
796 /**
797 * @tc.name: GetStores
798 * @tc.desc: Test GetStores function
799 * @tc.type: FUNC
800 * @tc.require:
801 */
802 HWTEST_F(CloudDataTest, GetStores, TestSize.Level0)
803 {
804 auto cloudServerMock = std::make_shared<CloudServerMock>();
805 auto user = AccountDelegate::GetInstance()->GetUserByToken(OHOS::IPCSkeleton::GetCallingTokenID());
806 auto [status, cloudInfo] = cloudServerMock->GetServerInfo(user, true);
807 SchemaMeta schemaMeta;
808 MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE), schemaMeta, true);
809 EXPECT_TRUE(!schemaMeta.GetStores().empty());
810 }
811
812 /**
813 * @tc.name: UpdateStartSyncInfo
814 * @tc.desc: Test UpdateStartSyncInfo
815 * @tc.type: FUNC
816 * @tc.require:
817 */
818 HWTEST_F(CloudDataTest, UpdateStartSyncInfo, TestSize.Level0)
819 {
820 int32_t user = 100;
821 CloudData::SyncManager sync;
822 CloudData::SyncManager::SyncInfo info(user, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
823 CloudInfo cloud;
824 cloud.user = info.user_;
825 auto cloudSyncInfos = sync.GetCloudSyncInfo(info, cloud);
826 sync.UpdateStartSyncInfo(cloudSyncInfos);
827 std::vector<CloudLastSyncInfo> lastSyncInfos;
828 MetaDataManager::GetInstance().LoadMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
829 ""), lastSyncInfos, true);
830 EXPECT_TRUE(!lastSyncInfos.empty());
831 printf("code: %d", lastSyncInfos[0].code);
832 EXPECT_TRUE(lastSyncInfos[0].code == -1);
833 EXPECT_TRUE(lastSyncInfos[0].startTime != 0);
834 EXPECT_TRUE(lastSyncInfos[0].finishTime != 0);
835 EXPECT_TRUE(lastSyncInfos[0].syncStatus == 1);
836 }
837
838 /**
839 * @tc.name: UpdateStartSyncInfo
840 * @tc.desc: Test UpdateStartSyncInfo
841 * @tc.type: FUNC
842 * @tc.require:
843 */
844 HWTEST_F(CloudDataTest, UpdateFinishSyncInfo, TestSize.Level0)
845 {
846 int32_t user = 100;
847 CloudData::SyncManager sync;
848 CloudData::SyncManager::SyncInfo info(user, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
849 CloudInfo cloud;
850 cloud.user = info.user_;
851 auto cloudSyncInfos = sync.GetCloudSyncInfo(info, cloud);
852 sync.UpdateStartSyncInfo(cloudSyncInfos);
853 sync.UpdateFinishSyncInfo({ user, TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1 }, 0, 0);
854 std::vector<CloudLastSyncInfo> lastSyncInfos;
855 MetaDataManager::GetInstance().LoadMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
856 ""), lastSyncInfos, true);
857 EXPECT_TRUE(!lastSyncInfos.empty());
858 }
859
860 /**
861 * @tc.name: Share
862 * @tc.desc:
863 * @tc.type: FUNC
864 * @tc.require:
865 */
866 HWTEST_F(CloudDataTest, Share001, TestSize.Level0)
867 {
868 std::string sharingRes = "";
869 CloudData::Participants participants{};
870 CloudData::Results results;
871 auto ret = cloudServiceImpl_->Share(sharingRes, participants, results);
872 EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
873 }
874
875 /**
876 * @tc.name: Unshare
877 * @tc.desc:
878 * @tc.type: FUNC
879 * @tc.require:
880 */
881 HWTEST_F(CloudDataTest, Unshare001, TestSize.Level0)
882 {
883 std::string sharingRes = "";
884 CloudData::Participants participants{};
885 CloudData::Results results;
886 auto ret = cloudServiceImpl_->Unshare(sharingRes, participants, results);
887 EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
888 }
889
890 /**
891 * @tc.name: ChangePrivilege
892 * @tc.desc:
893 * @tc.type: FUNC
894 * @tc.require:
895 */
896 HWTEST_F(CloudDataTest, ChangePrivilege001, TestSize.Level0)
897 {
898 std::string sharingRes = "";
899 CloudData::Participants participants{};
900 CloudData::Results results;
901 auto ret = cloudServiceImpl_->ChangePrivilege(sharingRes, participants, results);
902 EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
903 }
904
905 /**
906 * @tc.name: ChangeConfirmation
907 * @tc.desc:
908 * @tc.type: FUNC
909 * @tc.require:
910 */
911 HWTEST_F(CloudDataTest, ChangeConfirmation001, TestSize.Level0)
912 {
913 std::string sharingRes = "";
914 int32_t confirmation = 0;
915 std::pair<int32_t, std::string> result;
916 auto ret = cloudServiceImpl_->ChangeConfirmation(sharingRes, confirmation, result);
917 EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
918 }
919
920 /**
921 * @tc.name: ConfirmInvitation
922 * @tc.desc:
923 * @tc.type: FUNC
924 * @tc.require:
925 */
926 HWTEST_F(CloudDataTest, ConfirmInvitation001, TestSize.Level0)
927 {
928 std::string sharingRes = "";
929 int32_t confirmation = 0;
930 std::tuple<int32_t, std::string, std::string> result;
931 auto ret = cloudServiceImpl_->ConfirmInvitation(sharingRes, confirmation, result);
932 EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
933 }
934
935 /**
936 * @tc.name: Exit
937 * @tc.desc:
938 * @tc.type: FUNC
939 * @tc.require:
940 */
941 HWTEST_F(CloudDataTest, Exit001, TestSize.Level0)
942 {
943 std::string sharingRes = "";
944 std::pair<int32_t, std::string> result;
945 auto ret = cloudServiceImpl_->Exit(sharingRes, result);
946 EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
947 }
948
949 /**
950 * @tc.name: Query
951 * @tc.desc:
952 * @tc.type: FUNC
953 * @tc.require:
954 */
955 HWTEST_F(CloudDataTest, Query001, TestSize.Level0)
956 {
957 std::string sharingRes = "";
958 CloudData::QueryResults result;
959 auto ret = cloudServiceImpl_->Query(sharingRes, result);
960 EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
961 }
962
963 /**
964 * @tc.name: QueryByInvitation
965 * @tc.desc:
966 * @tc.type: FUNC
967 * @tc.require:
968 */
969 HWTEST_F(CloudDataTest, QueryByInvitation001, TestSize.Level0)
970 {
971 std::string invitation = "";
972 CloudData::QueryResults result;
973 auto ret = cloudServiceImpl_->QueryByInvitation(invitation, result);
974 EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
975 }
976
977 /**
978 * @tc.name: AllocResourceAndShare
979 * @tc.desc:
980 * @tc.type: FUNC
981 * @tc.require:
982 */
983 HWTEST_F(CloudDataTest, AllocResourceAndShare001, TestSize.Level0)
984 {
985 DistributedRdb::PredicatesMemo predicates;
986 predicates.tables_.push_back(TEST_CLOUD_BUNDLE);
987 std::vector<std::string> columns;
988 CloudData::Participants participants;
989 auto [ret, _] = cloudServiceImpl_->AllocResourceAndShare(TEST_CLOUD_STORE, predicates, columns, participants);
990 EXPECT_EQ(ret, E_ERROR);
__anon572e501f0402(const Event &event) 991 EventCenter::GetInstance().Subscribe(CloudEvent::MAKE_QUERY, [](const Event &event) {
992 auto &evt = static_cast<const DistributedData::MakeQueryEvent &>(event);
993 auto callback = evt.GetCallback();
994 if (!callback) {
995 return;
996 }
997 auto predicate = evt.GetPredicates();
998 auto rdbQuery = std::make_shared<DistributedRdb::RdbQuery>();
999 rdbQuery->MakeQuery(*predicate);
1000 rdbQuery->SetColumns(evt.GetColumns());
1001 callback(rdbQuery);
1002 });
1003 std::tie(ret, _) = cloudServiceImpl_->AllocResourceAndShare(TEST_CLOUD_STORE, predicates, columns, participants);
1004 EXPECT_EQ(ret, E_ERROR);
1005 }
1006
1007 /**
1008 * @tc.name: SetGlobalCloudStrategy
1009 * @tc.desc:
1010 * @tc.type: FUNC
1011 * @tc.require:
1012 */
1013 HWTEST_F(CloudDataTest, SetGlobalCloudStrategy001, TestSize.Level0)
1014 {
1015 std::vector<CommonType::Value> values;
1016 values.push_back(CloudData::NetWorkStrategy::WIFI);
1017 CloudData::Strategy strategy = CloudData::Strategy::STRATEGY_BUTT;
1018 auto ret = cloudServiceImpl_->SetGlobalCloudStrategy(strategy, values);
1019 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1020 strategy = CloudData::Strategy::STRATEGY_NETWORK;
1021 ret = cloudServiceImpl_->SetGlobalCloudStrategy(strategy, values);
1022 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1023 }
1024
1025 /**
1026 * @tc.name: SetCloudStrategy
1027 * @tc.desc:
1028 * @tc.type: FUNC
1029 * @tc.require:
1030 */
1031 HWTEST_F(CloudDataTest, SetCloudStrategy001, TestSize.Level0)
1032 {
1033 std::vector<CommonType::Value> values;
1034 values.push_back(CloudData::NetWorkStrategy::WIFI);
1035 CloudData::Strategy strategy = CloudData::Strategy::STRATEGY_BUTT;
1036 auto ret = cloudServiceImpl_->SetCloudStrategy(strategy, values);
1037 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1038 strategy = CloudData::Strategy::STRATEGY_NETWORK;
1039 ret = cloudServiceImpl_->SetCloudStrategy(strategy, values);
1040 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1041 }
1042
1043 /**
1044 * @tc.name: Clean
1045 * @tc.desc:
1046 * @tc.type: FUNC
1047 * @tc.require:
1048 */
1049 HWTEST_F(CloudDataTest, Clean001, TestSize.Level0)
1050 {
1051 std::map<std::string, int32_t> actions;
1052 actions.insert_or_assign(TEST_CLOUD_BUNDLE, CloudData::CloudService::Action::CLEAR_CLOUD_BUTT);
1053 std::string id = "testId";
1054 std::string bundleName = "testBundleName";
1055 auto ret = cloudServiceImpl_->Clean(id, actions);
1056 EXPECT_EQ(ret, CloudData::CloudService::ERROR);
1057 ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
1058 EXPECT_EQ(ret, CloudData::CloudService::ERROR);
1059 actions.insert_or_assign(TEST_CLOUD_BUNDLE, CloudData::CloudService::Action::CLEAR_CLOUD_INFO);
1060 actions.insert_or_assign(bundleName, CloudData::CloudService::Action::CLEAR_CLOUD_DATA_AND_INFO);
1061 ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
1062 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1063 }
1064
1065 /**
1066 * @tc.name: Clean
1067 * @tc.desc:
1068 * @tc.type: FUNC
1069 * @tc.require:
1070 */
1071 HWTEST_F(CloudDataTest, Clean002, TestSize.Level0)
1072 {
1073 MetaDataManager::GetInstance().DelMeta(metaData_.GetKey(), true);
1074 std::map<std::string, int32_t> actions;
1075 actions.insert_or_assign(TEST_CLOUD_BUNDLE, CloudData::CloudService::Action::CLEAR_CLOUD_INFO);
1076 auto ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
1077 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1078 StoreMetaDataLocal localMeta;
1079 localMeta.isPublic = false;
1080 MetaDataManager::GetInstance().SaveMeta(metaData_.GetKeyLocal(), localMeta, true);
1081 ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
1082 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1083 localMeta.isPublic = true;
1084 MetaDataManager::GetInstance().SaveMeta(metaData_.GetKeyLocal(), localMeta, true);
1085 ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
1086 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1087 metaData_.user = "0";
1088 MetaDataManager::GetInstance().SaveMeta(metaData_.GetKey(), metaData_, true);
1089 ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
1090 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1091 MetaDataManager::GetInstance().DelMeta(metaData_.GetKey(), true);
1092 metaData_.user = std::to_string(AccountDelegate::GetInstance()->GetUserByToken(metaData_.tokenId));
1093 MetaDataManager::GetInstance().DelMeta(metaData_.GetKeyLocal(), true);
1094 }
1095
1096 /**
1097 * @tc.name: NotifyDataChange
1098 * @tc.desc:
1099 * @tc.type: FUNC
1100 * @tc.require:
1101 */
1102 HWTEST_F(CloudDataTest, NotifyDataChange001, TestSize.Level0)
1103 {
1104 auto ret = cloudServiceImpl_->NotifyDataChange(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE);
1105 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1106 }
1107
1108 /**
1109 * @tc.name: NotifyDataChange
1110 * @tc.desc:
1111 * @tc.type: FUNC
1112 * @tc.require:
1113 */
1114 HWTEST_F(CloudDataTest, NotifyDataChange002, TestSize.Level0)
1115 {
1116 constexpr const int32_t invalidUserId = -1;
1117 std::string extraData;
1118 auto ret = cloudServiceImpl_->NotifyDataChange("", extraData, invalidUserId);
1119 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1120 ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, invalidUserId);
1121 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1122 extraData = "{data:test}";
1123 ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, invalidUserId);
1124 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1125 extraData = "{\"data\":\"{\\\"accountId\\\":\\\"id\\\",\\\"bundleName\\\":\\\"test_cloud_"
1126 "bundleName\\\",\\\"containerName\\\":\\\"test_cloud_database_alias_1\\\", \\\"databaseScopes\\\": "
1127 "\\\"[\\\\\\\"private\\\\\\\", "
1128 "\\\\\\\"shared\\\\\\\"]\\\",\\\"recordTypes\\\":\\\"[\\\\\\\"test_cloud_table_alias\\\\\\\"]\\\"}\"}";
1129 ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, invalidUserId);
1130 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1131 extraData = "{\"data\":\"{\\\"accountId\\\":\\\"test_cloud_id\\\",\\\"bundleName\\\":\\\"cloud_"
1132 "bundleName_test\\\",\\\"containerName\\\":\\\"test_cloud_database_alias_1\\\", "
1133 "\\\"databaseScopes\\\": "
1134 "\\\"[\\\\\\\"private\\\\\\\", "
1135 "\\\\\\\"shared\\\\\\\"]\\\",\\\"recordTypes\\\":\\\"[\\\\\\\"test_cloud_table_alias\\\\\\\"]\\\"}\"}";
1136 ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, invalidUserId);
1137 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1138 }
1139
1140 /**
1141 * @tc.name: NotifyDataChange
1142 * @tc.desc:
1143 * @tc.type: FUNC
1144 * @tc.require:
1145 */
1146 HWTEST_F(CloudDataTest, NotifyDataChange003, TestSize.Level0)
1147 {
1148 constexpr const int32_t userId = 100;
1149 constexpr const int32_t defaultUserId = 0;
1150 std::string extraData = "{\"data\":\"{\\\"accountId\\\":\\\"test_cloud_id\\\",\\\"bundleName\\\":\\\"test_cloud_"
1151 "bundleName\\\",\\\"containerName\\\":\\\"test_cloud_database_alias_1\\\", "
1152 "\\\"databaseScopes\\\": "
1153 "\\\"[\\\\\\\"private\\\\\\\", "
1154 "\\\\\\\"shared\\\\\\\"]\\\",\\\"recordTypes\\\":\\\"[\\\\\\\"\\\\\\\"]\\\"}\"}";
1155 auto ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, defaultUserId);
1156 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1157 extraData = "{\"data\":\"{\\\"accountId\\\":\\\"test_cloud_id\\\",\\\"bundleName\\\":\\\"test_cloud_"
1158 "bundleName\\\",\\\"containerName\\\":\\\"test_cloud_database_alias_1\\\", \\\"databaseScopes\\\": "
1159 "\\\"[\\\\\\\"private\\\\\\\", "
1160 "\\\\\\\"shared\\\\\\\"]\\\",\\\"recordTypes\\\":\\\"[\\\\\\\"test_cloud_table_alias\\\\\\\"]\\\"}\"}";
1161 ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, userId);
1162 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1163 }
1164
1165 /**
1166 * @tc.name: OnReady
1167 * @tc.desc:
1168 * @tc.type: FUNC
1169 * @tc.require:
1170 */
1171 HWTEST_F(CloudDataTest, OnReady001, TestSize.Level0)
1172 {
1173 std::string device = "test";
1174 auto ret = cloudServiceImpl_->OnReady(device);
1175 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1176 ret = cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID);
1177 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1178 }
1179
1180 /**
1181 * @tc.name: Offline
1182 * @tc.desc:
1183 * @tc.type: FUNC
1184 * @tc.require:
1185 */
1186 HWTEST_F(CloudDataTest, Offline001, TestSize.Level0)
1187 {
1188 std::string device = "test";
1189 auto ret = cloudServiceImpl_->Offline(device);
1190 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1191 ret = cloudServiceImpl_->Offline(DeviceManagerAdapter::CLOUD_DEVICE_UUID);
1192 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1193 }
1194
1195 /**
1196 * @tc.name: CloudShare
1197 * @tc.desc:
1198 * @tc.type: FUNC
1199 * @tc.require:
1200 */
1201 HWTEST_F(CloudDataTest, CloudShare001, TestSize.Level0)
1202 {
1203 StoreInfo storeInfo{ OHOS::IPCSkeleton::GetCallingTokenID(), TEST_CLOUD_BUNDLE, TEST_CLOUD_STORE, 0 };
1204 std::pair<int32_t, std::shared_ptr<Cursor>> result;
__anon572e501f0502(int32_t status, std::shared_ptr<Cursor> cursor) 1205 CloudShareEvent::Callback asyncCallback = [&result](int32_t status, std::shared_ptr<Cursor> cursor) {
1206 result.first = status;
1207 result.second = cursor;
1208 };
1209 auto event = std::make_unique<CloudShareEvent>(storeInfo, nullptr, nullptr);
1210 EventCenter::GetInstance().PostEvent(std::move(event));
1211 auto event1 = std::make_unique<CloudShareEvent>(storeInfo, nullptr, asyncCallback);
1212 EventCenter::GetInstance().PostEvent(std::move(event1));
1213 EXPECT_EQ(result.first, GeneralError::E_ERROR);
1214 auto rdbQuery = std::make_shared<DistributedRdb::RdbQuery>();
1215 auto event2 = std::make_unique<CloudShareEvent>(storeInfo, rdbQuery, nullptr);
1216 EventCenter::GetInstance().PostEvent(std::move(event2));
1217 auto event3 = std::make_unique<CloudShareEvent>(storeInfo, rdbQuery, asyncCallback);
1218 EventCenter::GetInstance().PostEvent(std::move(event3));
1219 EXPECT_EQ(result.first, GeneralError::E_ERROR);
1220 }
1221
1222 /**
1223 * @tc.name: OnUserChange
1224 * @tc.desc:
1225 * @tc.type: FUNC
1226 * @tc.require:
1227 */
1228 HWTEST_F(CloudDataTest, OnUserChange001, TestSize.Level0)
1229 {
1230 constexpr const uint32_t ACCOUNT_DEFAULT = 2;
1231 constexpr const uint32_t ACCOUNT_DELETE = 3;
1232 constexpr const uint32_t ACCOUNT_SWITCHED = 4;
1233 constexpr const uint32_t ACCOUNT_UNLOCKED = 5;
1234 auto ret = cloudServiceImpl_->OnUserChange(ACCOUNT_DEFAULT, "0", "test");
1235 EXPECT_EQ(ret, GeneralError::E_OK);
1236 ret = cloudServiceImpl_->OnUserChange(ACCOUNT_DELETE, "0", "test");
1237 EXPECT_EQ(ret, GeneralError::E_OK);
1238 ret = cloudServiceImpl_->OnUserChange(ACCOUNT_SWITCHED, "0", "test");
1239 EXPECT_EQ(ret, GeneralError::E_OK);
1240 ret = cloudServiceImpl_->OnUserChange(ACCOUNT_UNLOCKED, "0", "test");
1241 EXPECT_EQ(ret, GeneralError::E_OK);
1242 }
1243
1244 /**
1245 * @tc.name: DisableCloud
1246 * @tc.desc:
1247 * @tc.type: FUNC
1248 * @tc.require:
1249 */
1250 HWTEST_F(CloudDataTest, DisableCloud001, TestSize.Level0)
1251 {
1252 auto ret = cloudServiceImpl_->DisableCloud("test");
1253 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1254 ret = cloudServiceImpl_->DisableCloud(TEST_CLOUD_ID);
1255 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1256 }
1257
1258 /**
1259 * @tc.name: ChangeAppSwitch
1260 * @tc.desc:
1261 * @tc.type: FUNC
1262 * @tc.require:
1263 */
1264 HWTEST_F(CloudDataTest, ChangeAppSwitch, TestSize.Level0)
1265 {
1266 std::string id = "testId";
1267 std::string bundleName = "testName";
1268 auto ret = cloudServiceImpl_->ChangeAppSwitch(id, bundleName, CloudData::CloudService::SWITCH_ON);
1269 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1270 ret = cloudServiceImpl_->ChangeAppSwitch(TEST_CLOUD_ID, bundleName, CloudData::CloudService::SWITCH_ON);
1271 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1272 ret = cloudServiceImpl_->ChangeAppSwitch(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, CloudData::CloudService::SWITCH_OFF);
1273 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1274 }
1275
1276 /**
1277 * @tc.name: EnableCloud
1278 * @tc.desc:
1279 * @tc.type: FUNC
1280 * @tc.require:
1281 */
1282 HWTEST_F(CloudDataTest, EnableCloud, TestSize.Level0)
1283 {
1284 std::string bundleName = "testName";
1285 std::map<std::string, int32_t> switches;
1286 switches.insert_or_assign(TEST_CLOUD_BUNDLE, CloudData::CloudService::SWITCH_ON);
1287 switches.insert_or_assign(bundleName, CloudData::CloudService::SWITCH_ON);
1288 auto ret = cloudServiceImpl_->EnableCloud(TEST_CLOUD_ID, switches);
1289 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1290 }
1291
1292 /**
1293 * @tc.name: OnEnableCloud
1294 * @tc.desc:
1295 * @tc.type: FUNC
1296 * @tc.require:
1297 */
1298 HWTEST_F(CloudDataTest, OnEnableCloud, TestSize.Level0)
1299 {
1300 MessageParcel reply;
1301 MessageParcel data;
1302 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1303 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_ENABLE_CLOUD, data, reply);
1304 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1305 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1306 std::string id = "testId";
1307 std::map<std::string, int32_t> switches;
1308 ITypesUtil::Marshal(data, id, switches);
1309 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_ENABLE_CLOUD, data, reply);
1310 EXPECT_EQ(ret, ERR_NONE);
1311 }
1312
1313 /**
1314 * @tc.name: OnDisableCloud
1315 * @tc.desc:
1316 * @tc.type: FUNC
1317 * @tc.require:
1318 */
1319 HWTEST_F(CloudDataTest, OnDisableCloud, TestSize.Level0)
1320 {
1321 MessageParcel reply;
1322 MessageParcel data;
1323 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1324 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_DISABLE_CLOUD, data, reply);
1325 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1326 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1327 data.WriteString(TEST_CLOUD_ID);
1328 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_DISABLE_CLOUD, data, reply);
1329 EXPECT_EQ(ret, ERR_NONE);
1330 }
1331
1332 /**
1333 * @tc.name: OnChangeAppSwitch
1334 * @tc.desc:
1335 * @tc.type: FUNC
1336 * @tc.require:
1337 */
1338 HWTEST_F(CloudDataTest, OnChangeAppSwitch, TestSize.Level0)
1339 {
1340 MessageParcel reply;
1341 MessageParcel data;
1342 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1343 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_APP_SWITCH, data, reply);
1344 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1345 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1346 data.WriteString(TEST_CLOUD_ID);
1347 data.WriteString(TEST_CLOUD_BUNDLE);
1348 data.WriteInt32(CloudData::CloudService::SWITCH_ON);
1349 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_APP_SWITCH, data, reply);
1350 EXPECT_EQ(ret, ERR_NONE);
1351 }
1352
1353 /**
1354 * @tc.name: OnClean
1355 * @tc.desc:
1356 * @tc.type: FUNC
1357 * @tc.require:
1358 */
1359 HWTEST_F(CloudDataTest, OnClean, TestSize.Level0)
1360 {
1361 MessageParcel reply;
1362 MessageParcel data;
1363 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1364 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CLEAN, data, reply);
1365 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1366 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1367 std::string id = TEST_CLOUD_ID;
1368 std::map<std::string, int32_t> actions;
1369 ITypesUtil::Marshal(data, id, actions);
1370 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CLEAN, data, reply);
1371 EXPECT_EQ(ret, ERR_NONE);
1372 }
1373
1374 /**
1375 * @tc.name: OnNotifyDataChange
1376 * @tc.desc:
1377 * @tc.type: FUNC
1378 * @tc.require:
1379 */
1380 HWTEST_F(CloudDataTest, OnNotifyDataChange, TestSize.Level0)
1381 {
1382 MessageParcel reply;
1383 MessageParcel data;
1384 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1385 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_NOTIFY_DATA_CHANGE, data, reply);
1386 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1387 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1388 data.WriteString(TEST_CLOUD_ID);
1389 data.WriteString(TEST_CLOUD_BUNDLE);
1390 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_NOTIFY_DATA_CHANGE, data, reply);
1391 EXPECT_EQ(ret, ERR_NONE);
1392 }
1393
1394 /**
1395 * @tc.name: OnNotifyChange
1396 * @tc.desc:
1397 * @tc.type: FUNC
1398 * @tc.require:
1399 */
1400 HWTEST_F(CloudDataTest, OnNotifyChange, TestSize.Level0)
1401 {
1402 MessageParcel reply;
1403 MessageParcel data;
1404 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1405 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_NOTIFY_DATA_CHANGE_EXT, data, reply);
1406 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1407 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1408 data.WriteString(TEST_CLOUD_ID);
1409 data.WriteString(TEST_CLOUD_BUNDLE);
1410 int32_t userId = 100;
1411 data.WriteInt32(userId);
1412 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_NOTIFY_DATA_CHANGE_EXT, data, reply);
1413 EXPECT_EQ(ret, ERR_NONE);
1414 }
1415
1416 /**
1417 * @tc.name: OnQueryStatistics
1418 * @tc.desc:
1419 * @tc.type: FUNC
1420 * @tc.require:
1421 */
1422 HWTEST_F(CloudDataTest, OnQueryStatistics, TestSize.Level0)
1423 {
1424 MessageParcel reply;
1425 MessageParcel data;
1426 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1427 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_STATISTICS, data, reply);
1428 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1429 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1430 data.WriteString(TEST_CLOUD_ID);
1431 data.WriteString(TEST_CLOUD_BUNDLE);
1432 data.WriteString(TEST_CLOUD_STORE);
1433 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_STATISTICS, data, reply);
1434 EXPECT_EQ(ret, ERR_NONE);
1435 }
1436
1437 /**
1438 * @tc.name: OnQueryLastSyncInfo
1439 * @tc.desc:
1440 * @tc.type: FUNC
1441 * @tc.require:
1442 */
1443 HWTEST_F(CloudDataTest, OnQueryLastSyncInfo, TestSize.Level0)
1444 {
1445 MessageParcel reply;
1446 MessageParcel data;
1447 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1448 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_LAST_SYNC_INFO, data, reply);
1449 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1450 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1451 data.WriteString(TEST_CLOUD_ID);
1452 data.WriteString(TEST_CLOUD_BUNDLE);
1453 data.WriteString(TEST_CLOUD_STORE);
1454 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_LAST_SYNC_INFO, data, reply);
1455 EXPECT_EQ(ret, ERR_NONE);
1456 }
1457
1458 /**
1459 * @tc.name: OnSetGlobalCloudStrategy
1460 * @tc.desc:
1461 * @tc.type: FUNC
1462 * @tc.require:
1463 */
1464 HWTEST_F(CloudDataTest, OnSetGlobalCloudStrategy, TestSize.Level0)
1465 {
1466 MessageParcel reply;
1467 MessageParcel data;
1468 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1469 auto ret =
1470 cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SET_GLOBAL_CLOUD_STRATEGY, data, reply);
1471 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1472 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1473 uint32_t strategy = 0;
1474 std::vector<CommonType::Value> values;
1475 ITypesUtil::Marshal(data, strategy, values);
1476 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SET_GLOBAL_CLOUD_STRATEGY, data, reply);
1477 EXPECT_EQ(ret, ERR_NONE);
1478 }
1479
1480 /**
1481 * @tc.name: OnAllocResourceAndShare
1482 * @tc.desc:
1483 * @tc.type: FUNC
1484 * @tc.require:
1485 */
1486 HWTEST_F(CloudDataTest, OnAllocResourceAndShare, TestSize.Level0)
1487 {
1488 MessageParcel reply;
1489 MessageParcel data;
1490 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1491 auto ret = cloudServiceImpl_->OnRemoteRequest(
1492 CloudData::CloudService::TRANS_ALLOC_RESOURCE_AND_SHARE, data, reply);
1493 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1494 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1495 std::string storeId = "storeId";
1496 DistributedRdb::PredicatesMemo predicates;
1497 std::vector<std::string> columns;
1498 std::vector<CloudData::Participant> participants;
1499 ITypesUtil::Marshal(data, storeId, predicates, columns, participants);
1500 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_ALLOC_RESOURCE_AND_SHARE, data, reply);
1501 EXPECT_EQ(ret, ERR_NONE);
1502 }
1503
1504 /**
1505 * @tc.name: OnShare
1506 * @tc.desc:
1507 * @tc.type: FUNC
1508 * @tc.require:
1509 */
1510 HWTEST_F(CloudDataTest, OnShare, TestSize.Level0)
1511 {
1512 MessageParcel reply;
1513 MessageParcel data;
1514 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1515 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SHARE, data, reply);
1516 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1517 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1518 std::string sharingRes;
1519 CloudData::Participants participants;
1520 CloudData::Results results;
1521 ITypesUtil::Marshal(data, sharingRes, participants, results);
1522 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SHARE, data, reply);
1523 EXPECT_EQ(ret, ERR_NONE);
1524 }
1525
1526 /**
1527 * @tc.name: OnUnshare
1528 * @tc.desc:
1529 * @tc.type: FUNC
1530 * @tc.require:
1531 */
1532 HWTEST_F(CloudDataTest, OnUnshare, TestSize.Level0)
1533 {
1534 MessageParcel reply;
1535 MessageParcel data;
1536 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1537 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_UNSHARE, data, reply);
1538 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1539 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1540 std::string sharingRes;
1541 CloudData::Participants participants;
1542 CloudData::Results results;
1543 ITypesUtil::Marshal(data, sharingRes, participants, results);
1544 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_UNSHARE, data, reply);
1545 EXPECT_EQ(ret, ERR_NONE);
1546 }
1547
1548 /**
1549 * @tc.name: OnExit
1550 * @tc.desc:
1551 * @tc.type: FUNC
1552 * @tc.require:
1553 */
1554 HWTEST_F(CloudDataTest, OnExit, TestSize.Level0)
1555 {
1556 MessageParcel reply;
1557 MessageParcel data;
1558 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1559 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_EXIT, data, reply);
1560 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1561 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1562 std::string sharingRes;
1563 std::pair<int32_t, std::string> result;
1564 ITypesUtil::Marshal(data, sharingRes, result);
1565 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_EXIT, data, reply);
1566 EXPECT_EQ(ret, ERR_NONE);
1567 }
1568
1569 /**
1570 * @tc.name: OnChangePrivilege
1571 * @tc.desc:
1572 * @tc.type: FUNC
1573 * @tc.require:
1574 */
1575 HWTEST_F(CloudDataTest, OnChangePrivilege, TestSize.Level0)
1576 {
1577 MessageParcel reply;
1578 MessageParcel data;
1579 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1580 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_PRIVILEGE, data, reply);
1581 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1582 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1583 std::string sharingRes;
1584 CloudData::Participants participants;
1585 CloudData::Results results;
1586 ITypesUtil::Marshal(data, sharingRes, participants, results);
1587 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_PRIVILEGE, data, reply);
1588 EXPECT_EQ(ret, ERR_NONE);
1589 }
1590
1591 /**
1592 * @tc.name: OnQuery
1593 * @tc.desc:
1594 * @tc.type: FUNC
1595 * @tc.require:
1596 */
1597 HWTEST_F(CloudDataTest, OnQuery, TestSize.Level0)
1598 {
1599 MessageParcel reply;
1600 MessageParcel data;
1601 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1602 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY, data, reply);
1603 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1604 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1605 std::string sharingRes;
1606 CloudData::QueryResults results;
1607 ITypesUtil::Marshal(data, sharingRes, results);
1608 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY, data, reply);
1609 EXPECT_EQ(ret, ERR_NONE);
1610 }
1611
1612 /**
1613 * @tc.name: OnQueryByInvitation
1614 * @tc.desc:
1615 * @tc.type: FUNC
1616 * @tc.require:
1617 */
1618 HWTEST_F(CloudDataTest, OnQueryByInvitation, TestSize.Level0)
1619 {
1620 MessageParcel reply;
1621 MessageParcel data;
1622 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1623 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_BY_INVITATION, data, reply);
1624 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1625 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1626 std::string invitation;
1627 CloudData::QueryResults results;
1628 ITypesUtil::Marshal(data, invitation, results);
1629 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_BY_INVITATION, data, reply);
1630 EXPECT_EQ(ret, ERR_NONE);
1631 }
1632
1633 /**
1634 * @tc.name: OnConfirmInvitation
1635 * @tc.desc:
1636 * @tc.type: FUNC
1637 * @tc.require:
1638 */
1639 HWTEST_F(CloudDataTest, OnConfirmInvitation, TestSize.Level0)
1640 {
1641 MessageParcel reply;
1642 MessageParcel data;
1643 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1644 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CONFIRM_INVITATION, data, reply);
1645 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1646 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1647 std::string invitation;
1648 int32_t confirmation = 0;
1649 std::tuple<int32_t, std::string, std::string> result;
1650 ITypesUtil::Marshal(data, invitation, confirmation, result);
1651 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CONFIRM_INVITATION, data, reply);
1652 EXPECT_EQ(ret, ERR_NONE);
1653 }
1654
1655 /**
1656 * @tc.name: OnChangeConfirmation
1657 * @tc.desc:
1658 * @tc.type: FUNC
1659 * @tc.require:
1660 */
1661 HWTEST_F(CloudDataTest, OnChangeConfirmation, TestSize.Level0)
1662 {
1663 MessageParcel reply;
1664 MessageParcel data;
1665 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1666 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_CONFIRMATION, data, reply);
1667 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1668 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1669 std::string sharingRes;
1670 int32_t confirmation = 0;
1671 std::pair<int32_t, std::string> result;
1672 ITypesUtil::Marshal(data, sharingRes, confirmation, result);
1673 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_CONFIRMATION, data, reply);
1674 EXPECT_EQ(ret, ERR_NONE);
1675 }
1676
1677 /**
1678 * @tc.name: OnSetCloudStrategy
1679 * @tc.desc:
1680 * @tc.type: FUNC
1681 * @tc.require:
1682 */
1683 HWTEST_F(CloudDataTest, OnSetCloudStrategy, TestSize.Level0)
1684 {
1685 MessageParcel reply;
1686 MessageParcel data;
1687 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1688 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SET_CLOUD_STRATEGY, data, reply);
1689 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1690 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1691 uint32_t strategy = 0;
1692 std::vector<CommonType::Value> values;
1693 ITypesUtil::Marshal(data, strategy, values);
1694 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SET_CLOUD_STRATEGY, data, reply);
1695 EXPECT_EQ(ret, ERR_NONE);
1696 }
1697
1698 /**
1699 * @tc.name: SharingUtil001
1700 * @tc.desc:
1701 * @tc.type: FUNC
1702 * @tc.require:
1703 */
1704 HWTEST_F(CloudDataTest, SharingUtil001, TestSize.Level0)
1705 {
1706 auto cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_UNKNOWN);
1707 EXPECT_EQ(cfm, SharingCfm::CFM_UNKNOWN);
1708 cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_ACCEPTED);
1709 EXPECT_EQ(cfm, SharingCfm::CFM_ACCEPTED);
1710 cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_REJECTED);
1711 EXPECT_EQ(cfm, SharingCfm::CFM_REJECTED);
1712 cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_SUSPENDED);
1713 EXPECT_EQ(cfm, SharingCfm::CFM_SUSPENDED);
1714 cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_UNAVAILABLE);
1715 EXPECT_EQ(cfm, SharingCfm::CFM_UNAVAILABLE);
1716 cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_BUTT);
1717 EXPECT_EQ(cfm, SharingCfm::CFM_UNKNOWN);
1718 }
1719
1720 /**
1721 * @tc.name: SharingUtil002
1722 * @tc.desc:
1723 * @tc.type: FUNC
1724 * @tc.require:
1725 */
1726 HWTEST_F(CloudDataTest, SharingUtil002, TestSize.Level0)
1727 {
1728 auto cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_UNKNOWN);
1729 EXPECT_EQ(cfm, Confirmation::CFM_UNKNOWN);
1730 cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_ACCEPTED);
1731 EXPECT_EQ(cfm, Confirmation::CFM_ACCEPTED);
1732 cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_REJECTED);
1733 EXPECT_EQ(cfm, Confirmation::CFM_REJECTED);
1734 cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_SUSPENDED);
1735 EXPECT_EQ(cfm, Confirmation::CFM_SUSPENDED);
1736 cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_UNAVAILABLE);
1737 EXPECT_EQ(cfm, Confirmation::CFM_UNAVAILABLE);
1738 cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_BUTT);
1739 EXPECT_EQ(cfm, Confirmation::CFM_UNKNOWN);
1740 }
1741
1742 /**
1743 * @tc.name: SharingUtil003
1744 * @tc.desc:
1745 * @tc.type: FUNC
1746 * @tc.require:
1747 */
1748 HWTEST_F(CloudDataTest, SharingUtil003, TestSize.Level0)
1749 {
1750 auto status = CloudData::SharingUtil::Convert(CenterCode::IPC_ERROR);
1751 EXPECT_EQ(status, Status::IPC_ERROR);
1752 status = CloudData::SharingUtil::Convert(CenterCode::NOT_SUPPORT);
1753 EXPECT_EQ(status, Status::SUCCESS);
1754 }
1755
1756 /**
1757 * @tc.name: SharingUtil004
1758 * @tc.desc:
1759 * @tc.type: FUNC
1760 * @tc.require:
1761 */
1762 HWTEST_F(CloudDataTest, SharingUtil004, TestSize.Level0)
1763 {
1764 auto status = CloudData::SharingUtil::Convert(GenErr::E_OK);
1765 EXPECT_EQ(status, Status::SUCCESS);
1766 status = CloudData::SharingUtil::Convert(GenErr::E_ERROR);
1767 EXPECT_EQ(status, Status::ERROR);
1768 status = CloudData::SharingUtil::Convert(GenErr::E_INVALID_ARGS);
1769 EXPECT_EQ(status, Status::INVALID_ARGUMENT);
1770 status = CloudData::SharingUtil::Convert(GenErr::E_BLOCKED_BY_NETWORK_STRATEGY);
1771 EXPECT_EQ(status, Status::STRATEGY_BLOCKING);
1772 status = CloudData::SharingUtil::Convert(GenErr::E_CLOUD_DISABLED);
1773 EXPECT_EQ(status, Status::CLOUD_DISABLE);
1774 status = CloudData::SharingUtil::Convert(GenErr::E_NETWORK_ERROR);
1775 EXPECT_EQ(status, Status::NETWORK_ERROR);
1776 status = CloudData::SharingUtil::Convert(GenErr::E_BUSY);
1777 EXPECT_EQ(status, Status::ERROR);
1778 }
1779
1780 /**
1781 * @tc.name: DoCloudSync
1782 * @tc.desc: Test the executor_ uninitialized and initialized scenarios
1783 * @tc.type: FUNC
1784 * @tc.require:
1785 */
1786 HWTEST_F(CloudDataTest, DoCloudSync, TestSize.Level0)
1787 {
1788 int32_t user = 100;
1789 CloudData::SyncManager sync;
1790 CloudData::SyncManager::SyncInfo info(user);
1791 auto ret = sync.DoCloudSync(info);
1792 EXPECT_EQ(ret, GenErr::E_NOT_INIT);
1793 ret = sync.StopCloudSync(user);
1794 EXPECT_EQ(ret, GenErr::E_NOT_INIT);
1795 size_t max = 12;
1796 size_t min = 5;
1797 sync.executor_ = std::make_shared<ExecutorPool>(max, min);
1798 ret = sync.DoCloudSync(info);
1799 EXPECT_EQ(ret, GenErr::E_OK);
1800 int32_t invalidUser = -1;
1801 sync.StopCloudSync(invalidUser);
1802 ret = sync.StopCloudSync(user);
1803 EXPECT_EQ(ret, GenErr::E_OK);
1804 }
1805
1806 /**
1807 * @tc.name: GetPostEventTask
1808 * @tc.desc: Test the interface to verify the package name and table name
1809 * @tc.type: FUNC
1810 * @tc.require:
1811 */
1812 HWTEST_F(CloudDataTest, GetPostEventTask, TestSize.Level0)
1813 {
1814 std::vector<SchemaMeta> schemas;
1815 schemaMeta_.databases[0].name = "test";
1816 schemas.push_back(schemaMeta_);
1817 schemaMeta_.bundleName = "test";
1818 schemas.push_back(schemaMeta_);
1819
1820 int32_t user = 100;
1821 CloudData::SyncManager::SyncInfo info(user);
1822 std::vector<std::string> value;
1823 info.tables_.insert_or_assign(TEST_CLOUD_STORE, value);
1824
1825 CloudData::SyncManager sync;
1826 std::map<std::string, std::string> traceIds;
1827 auto task = sync.GetPostEventTask(schemas, cloudInfo_, info, true, traceIds);
1828 task();
1829 std::vector<CloudLastSyncInfo> lastSyncInfos;
1830 MetaDataManager::GetInstance().LoadMeta(CloudLastSyncInfo::GetKey(user, "test", "test"), lastSyncInfos, true);
1831 EXPECT_TRUE(lastSyncInfos.size() == 0);
1832 }
1833
1834 /**
1835 * @tc.name: GetRetryer
1836 * @tc.desc: Test the input parameters of different interfaces
1837 * @tc.type: FUNC
1838 * @tc.require:
1839 */
1840 HWTEST_F(CloudDataTest, GetRetryer, TestSize.Level0)
1841 {
1842 int32_t user = 100;
1843 CloudData::SyncManager::SyncInfo info(user);
1844 CloudData::SyncManager sync;
1845 CloudData::SyncManager::Duration duration;
1846 std::string prepareTraceId;
1847 auto ret = sync.GetRetryer(CloudData::SyncManager::RETRY_TIMES, info, user)(duration, E_OK, E_OK, prepareTraceId);
1848 EXPECT_TRUE(ret);
1849 ret = sync.GetRetryer(CloudData::SyncManager::RETRY_TIMES, info, user)(
1850 duration, E_SYNC_TASK_MERGED, E_SYNC_TASK_MERGED, prepareTraceId);
1851 EXPECT_TRUE(ret);
1852 ret = sync.GetRetryer(0, info, user)(duration, E_OK, E_OK, prepareTraceId);
1853 EXPECT_TRUE(ret);
1854 ret = sync.GetRetryer(0, info, user)(duration, E_SYNC_TASK_MERGED, E_SYNC_TASK_MERGED, prepareTraceId);
1855 EXPECT_TRUE(ret);
1856 }
1857
1858 /**
1859 * @tc.name: GetCallback
1860 * @tc.desc: Test the processing logic of different progress callbacks
1861 * @tc.type: FUNC
1862 * @tc.require:
1863 */
1864 HWTEST_F(CloudDataTest, GetCallback, TestSize.Level0)
1865 {
1866 int32_t user = 100;
1867 CloudData::SyncManager::SyncInfo info(user);
1868 CloudData::SyncManager sync;
1869 DistributedData::GenDetails result;
1870 StoreInfo storeInfo;
1871 storeInfo.user = user;
1872 storeInfo.bundleName = "testBundleName";
1873 int32_t triggerMode = MODE_DEFAULT;
1874 std::string prepareTraceId;
1875 GenAsync async = nullptr;
1876 sync.GetCallback(async, storeInfo, triggerMode, prepareTraceId, user)(result);
1877 int32_t process = 0;
__anon572e501f0602(const GenDetails &details) 1878 async = [&process](const GenDetails &details) {
1879 process = details.begin()->second.progress;
1880 };
1881 GenProgressDetail detail;
1882 detail.progress = GenProgress::SYNC_IN_PROGRESS;
1883 result.insert_or_assign("test", detail);
1884 sync.GetCallback(async, storeInfo, triggerMode, prepareTraceId, user)(result);
1885 EXPECT_EQ(process, GenProgress::SYNC_IN_PROGRESS);
1886 detail.progress = GenProgress::SYNC_FINISH;
1887 result.insert_or_assign("test", detail);
1888 storeInfo.user = -1;
1889 sync.GetCallback(async, storeInfo, triggerMode, prepareTraceId, user)(result);
1890 storeInfo.user = user;
1891 sync.GetCallback(async, storeInfo, triggerMode, prepareTraceId, user)(result);
1892 EXPECT_EQ(process, GenProgress::SYNC_FINISH);
1893 }
1894
1895 /**
1896 * @tc.name: GetInterval
1897 * @tc.desc: Test the Interval transformation logic of the interface
1898 * @tc.type: FUNC
1899 * @tc.require:
1900 */
1901 HWTEST_F(CloudDataTest, GetInterval, TestSize.Level0)
1902 {
1903 CloudData::SyncManager sync;
1904
1905 auto ret = sync.GetInterval(E_LOCKED_BY_OTHERS);
1906 EXPECT_EQ(ret, CloudData::SyncManager::LOCKED_INTERVAL);
1907 ret = sync.GetInterval(E_BUSY);
1908 EXPECT_EQ(ret, CloudData::SyncManager::BUSY_INTERVAL);
1909 ret = sync.GetInterval(E_OK);
1910 EXPECT_EQ(ret, CloudData::SyncManager::RETRY_INTERVAL);
1911 }
1912
1913 /**
1914 * @tc.name: GetCloudSyncInfo
1915 * @tc.desc: Test get cloudInfo
1916 * @tc.type: FUNC
1917 * @tc.require:
1918 */
1919 HWTEST_F(CloudDataTest, GetCloudSyncInfo, TestSize.Level0)
1920 {
1921 CloudData::SyncManager sync;
1922 CloudInfo cloud;
1923 cloud.user = cloudInfo_.user;
1924 cloud.enableCloud = false;
1925 CloudData::SyncManager::SyncInfo info(cloudInfo_.user);
1926 MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
1927 info.bundleName_ = TEST_CLOUD_BUNDLE;
1928 auto ret = sync.GetCloudSyncInfo(info, cloud);
1929 EXPECT_TRUE(!ret.empty());
1930 }
1931
1932 /**
1933 * @tc.name: RetryCallback
1934 * @tc.desc: Test the retry logic
1935 * @tc.type: FUNC
1936 * @tc.require:
1937 */
1938 HWTEST_F(CloudDataTest, RetryCallback, TestSize.Level0)
1939 {
1940 int32_t user = 100;
1941 std::string prepareTraceId;
1942 CloudData::SyncManager sync;
1943 StoreInfo storeInfo;
1944 int32_t retCode = -1;
1945 CloudData::SyncManager::Retryer retry = [&retCode](CloudData::SyncManager::Duration interval, int32_t code,
__anon572e501f0702(CloudData::SyncManager::Duration interval, int32_t code, int32_t dbCode, const std::string &prepareTraceId) 1946 int32_t dbCode, const std::string &prepareTraceId) {
1947 retCode = code;
1948 return true;
1949 };
1950 DistributedData::GenDetails result;
1951 auto task = sync.RetryCallback(storeInfo, retry, MODE_DEFAULT, prepareTraceId, user);
1952 task(result);
1953 GenProgressDetail detail;
1954 detail.progress = GenProgress::SYNC_IN_PROGRESS;
1955 detail.code = 100;
1956 result.insert_or_assign("test", detail);
1957 task = sync.RetryCallback(storeInfo, retry, MODE_DEFAULT, prepareTraceId, user);
1958 task(result);
1959 EXPECT_EQ(retCode, detail.code);
1960 }
1961
1962 /**
1963 * @tc.name: UpdateCloudInfoFromServer
1964 * @tc.desc: Test updating cloudinfo from the server
1965 * @tc.type: FUNC
1966 * @tc.require:
1967 */
1968 HWTEST_F(CloudDataTest, UpdateCloudInfoFromServer, TestSize.Level0)
1969 {
1970 auto ret = cloudServiceImpl_->UpdateCloudInfoFromServer(cloudInfo_.user);
1971 EXPECT_EQ(ret, E_OK);
1972 }
1973
1974 /**
1975 * @tc.name: GetCloudInfo
1976 * @tc.desc: Test get cloudInfo
1977 * @tc.type: FUNC
1978 * @tc.require:
1979 */
1980 HWTEST_F(CloudDataTest, GetCloudInfo, TestSize.Level0)
1981 {
1982 MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
1983 auto ret = cloudServiceImpl_->GetCloudInfo(cloudInfo_.user);
1984 EXPECT_EQ(ret.first, CloudData::SUCCESS);
1985 }
1986
1987 /**
1988 * @tc.name: SubTask
1989 * @tc.desc: Test the subtask execution logic
1990 * @tc.type: FUNC
1991 * @tc.require:
1992 */
1993 HWTEST_F(CloudDataTest, SubTask, TestSize.Level0)
1994 {
1995 DistributedData::Subscription sub;
1996 cloudServiceImpl_->InitSubTask(sub, 0);
1997 MetaDataManager::GetInstance().LoadMeta(Subscription::GetKey(cloudInfo_.user), sub, true);
1998 cloudServiceImpl_->InitSubTask(sub, 0);
1999 int32_t userId = 0;
__anon572e501f0802() 2000 CloudData::CloudServiceImpl::Task task = [&userId]() {
2001 userId = cloudInfo_.user;
2002 };
2003 cloudServiceImpl_->GenSubTask(task, cloudInfo_.user)();
2004 EXPECT_EQ(userId, cloudInfo_.user);
2005 }
2006
2007 /**
2008 * @tc.name: ConvertCursor
2009 * @tc.desc: Test the cursor conversion logic when the ResultSet is empty and non-null
2010 * @tc.type: FUNC
2011 * @tc.require:
2012 */
2013 HWTEST_F(CloudDataTest, ConvertCursor, TestSize.Level0)
2014 {
2015 std::map<std::string, DistributedData::Value> entry;
2016 entry.insert_or_assign("test", "entry");
2017 auto resultSet = std::make_shared<CursorMock::ResultSet>(1, entry);
2018 auto cursor = std::make_shared<CursorMock>(resultSet);
2019 auto result = cloudServiceImpl_->ConvertCursor(cursor);
2020 EXPECT_TRUE(!result.empty());
2021 auto resultSet1 = std::make_shared<CursorMock::ResultSet>();
2022 auto cursor1 = std::make_shared<CursorMock>(resultSet1);
2023 auto result1 = cloudServiceImpl_->ConvertCursor(cursor1);
2024 EXPECT_TRUE(result1.empty());
2025 }
2026
2027 /**
2028 * @tc.name: GetDbInfoFromExtraData
2029 * @tc.desc: Test the GetDbInfoFromExtraData function input parameters of different parameters
2030 * @tc.type: FUNC
2031 * @tc.require:
2032 */
2033 HWTEST_F(CloudDataTest, GetDbInfoFromExtraData, TestSize.Level0)
2034 {
2035 SchemaMeta::Database database;
2036 database.name = TEST_CLOUD_STORE;
2037 database.alias = TEST_CLOUD_DATABASE_ALIAS_1;
2038
2039 SchemaMeta schemaMeta;
2040 schemaMeta.databases.push_back(database);
2041
2042 SchemaMeta::Table table;
2043 table.name = "test_cloud_table_name";
2044 table.alias = "test_cloud_table_alias";
2045 database.tables.push_back(table);
2046 SchemaMeta::Table table1;
2047 table1.name = "test_cloud_table_name1";
2048 table1.alias = "test_cloud_table_alias1";
2049 table1.sharedTableName = "test_share_table_name1";
2050 database.tables.emplace_back(table1);
2051
2052 database.alias = TEST_CLOUD_DATABASE_ALIAS_2;
2053 schemaMeta.databases.push_back(database);
2054
2055 ExtraData extraData;
2056 extraData.info.containerName = TEST_CLOUD_DATABASE_ALIAS_2;
2057 auto result = cloudServiceImpl_->GetDbInfoFromExtraData(extraData, schemaMeta);
2058 EXPECT_EQ(result.begin()->first, TEST_CLOUD_STORE);
2059
2060 std::string tableName = "test_cloud_table_alias2";
2061 extraData.info.tables.emplace_back(tableName);
2062 result = cloudServiceImpl_->GetDbInfoFromExtraData(extraData, schemaMeta);
2063 EXPECT_EQ(result.begin()->first, TEST_CLOUD_STORE);
2064
2065 std::string tableName1 = "test_cloud_table_alias1";
2066 extraData.info.tables.emplace_back(tableName1);
2067 extraData.info.scopes.emplace_back(DistributedData::ExtraData::SHARED_TABLE);
2068 result = cloudServiceImpl_->GetDbInfoFromExtraData(extraData, schemaMeta);
2069 EXPECT_EQ(result.begin()->first, TEST_CLOUD_STORE);
2070 }
2071
2072 /**
2073 * @tc.name: QueryTableStatistic
2074 * @tc.desc: Test the QueryTableStatistic function input parameters of different parameters
2075 * @tc.type: FUNC
2076 * @tc.require:
2077 */
2078 HWTEST_F(CloudDataTest, QueryTableStatistic, TestSize.Level0)
2079 {
2080 auto store = std::make_shared<GeneralStoreMock>();
2081 if (store != nullptr) {
2082 std::map<std::string, Value> entry = { { "inserted", "TEST" }, { "updated", "TEST" }, { "normal", "TEST" } };
2083 store->MakeCursor(entry);
2084 }
2085 auto [ret, result] = cloudServiceImpl_->QueryTableStatistic("test", store);
2086 EXPECT_TRUE(ret);
2087 if (store != nullptr) {
2088 std::map<std::string, Value> entry = { { "Test", 1 } };
2089 store->MakeCursor(entry);
2090 }
2091 std::tie(ret, result) = cloudServiceImpl_->QueryTableStatistic("test", store);
2092 EXPECT_TRUE(ret);
2093
2094 if (store != nullptr) {
2095 store->cursor_ = nullptr;
2096 }
2097 std::tie(ret, result) = cloudServiceImpl_->QueryTableStatistic("test", store);
2098 EXPECT_FALSE(ret);
2099 }
2100
2101 /**
2102 * @tc.name: GetSchemaMeta
2103 * @tc.desc: Test the GetSchemaMeta function input parameters of different parameters
2104 * @tc.type: FUNC
2105 * @tc.require:
2106 */
2107 HWTEST_F(CloudDataTest, GetSchemaMeta, TestSize.Level0)
2108 {
2109 int32_t userId = 101;
2110 int32_t instanceId = 0;
2111 CloudInfo cloudInfo;
2112 cloudInfo.user = userId;
2113 cloudInfo.id = TEST_CLOUD_ID;
2114 cloudInfo.enableCloud = true;
2115
2116 CloudInfo::AppInfo appInfo;
2117 appInfo.bundleName = TEST_CLOUD_BUNDLE;
2118 appInfo.appId = TEST_CLOUD_APPID;
2119 appInfo.version = 1;
2120 appInfo.cloudSwitch = true;
2121
2122 cloudInfo.apps[TEST_CLOUD_BUNDLE] = std::move(appInfo);
2123 MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true);
2124 std::string bundleName = "testName";
2125 auto [status, meta] = cloudServiceImpl_->GetSchemaMeta(userId, bundleName, instanceId);
2126 EXPECT_EQ(status, CloudData::CloudService::ERROR);
2127 bundleName = TEST_CLOUD_BUNDLE;
2128 DistributedData::SchemaMeta schemeMeta;
2129 schemeMeta.bundleName = TEST_CLOUD_BUNDLE;
2130 schemeMeta.metaVersion = DistributedData::SchemaMeta::CURRENT_VERSION + 1;
2131 MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE, instanceId), schemeMeta, true);
2132 std::tie(status, meta) = cloudServiceImpl_->GetSchemaMeta(userId, bundleName, instanceId);
2133 EXPECT_EQ(status, CloudData::CloudService::ERROR);
2134 schemeMeta.metaVersion = DistributedData::SchemaMeta::CURRENT_VERSION;
2135 MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE, instanceId), schemeMeta, true);
2136 std::tie(status, meta) = cloudServiceImpl_->GetSchemaMeta(userId, bundleName, instanceId);
2137 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
2138 EXPECT_EQ(meta.metaVersion, DistributedData::SchemaMeta::CURRENT_VERSION);
2139 MetaDataManager::GetInstance().DelMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE, instanceId), true);
2140 MetaDataManager::GetInstance().DelMeta(cloudInfo.GetKey(), true);
2141 }
2142
2143 /**
2144 * @tc.name: GetAppSchemaFromServer
2145 * @tc.desc: Test the GetAppSchemaFromServer function input parameters of different parameters
2146 * @tc.type: FUNC
2147 * @tc.require:
2148 */
2149 HWTEST_F(CloudDataTest, GetAppSchemaFromServer, TestSize.Level0)
2150 {
2151 int32_t userId = CloudServerMock::INVALID_USER_ID;
2152 std::string bundleName;
2153 delegate_.isNetworkAvailable_ = false;
2154 auto [status, meta] = cloudServiceImpl_->GetAppSchemaFromServer(userId, bundleName);
2155 EXPECT_EQ(status, CloudData::CloudService::NETWORK_ERROR);
2156 delegate_.isNetworkAvailable_ = true;
2157 std::tie(status, meta) = cloudServiceImpl_->GetAppSchemaFromServer(userId, bundleName);
2158 EXPECT_EQ(status, CloudData::CloudService::SCHEMA_INVALID);
2159 userId = 100;
2160 std::tie(status, meta) = cloudServiceImpl_->GetAppSchemaFromServer(userId, bundleName);
2161 EXPECT_EQ(status, CloudData::CloudService::SCHEMA_INVALID);
2162 bundleName = TEST_CLOUD_BUNDLE;
2163 std::tie(status, meta) = cloudServiceImpl_->GetAppSchemaFromServer(userId, bundleName);
2164 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
2165 EXPECT_EQ(meta.bundleName, schemaMeta_.bundleName);
2166 }
2167
2168 /**
2169 * @tc.name: OnAppUninstall
2170 * @tc.desc: Test the OnAppUninstall function delete the subscription data
2171 * @tc.type: FUNC
2172 * @tc.require:
2173 */
2174 HWTEST_F(CloudDataTest, OnAppUninstall, TestSize.Level0)
2175 {
2176 CloudData::CloudServiceImpl::CloudStatic cloudStatic;
2177 int32_t userId = 1001;
2178 Subscription sub;
2179 sub.expiresTime.insert_or_assign(TEST_CLOUD_BUNDLE, 0);
2180 MetaDataManager::GetInstance().SaveMeta(Subscription::GetKey(userId), sub, true);
2181 CloudInfo cloudInfo;
2182 cloudInfo.user = userId;
2183 CloudInfo::AppInfo appInfo;
2184 cloudInfo.apps.insert_or_assign(TEST_CLOUD_BUNDLE, appInfo);
2185 MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true);
2186 int32_t index = 1;
2187 auto ret = cloudStatic.OnAppUninstall(TEST_CLOUD_BUNDLE, userId, index);
2188 EXPECT_EQ(ret, E_OK);
2189 Subscription sub1;
2190 EXPECT_TRUE(MetaDataManager::GetInstance().LoadMeta(Subscription::GetKey(userId), sub1, true));
2191 EXPECT_EQ(sub1.expiresTime.size(), 0);
2192 }
2193
2194 /**
2195 * @tc.name: GetCloudInfo
2196 * @tc.desc: Test the GetCloudInfo with invalid parameters
2197 * @tc.type: FUNC
2198 * @tc.require:
2199 */
2200 HWTEST_F(CloudDataTest, GetCloudInfo001, TestSize.Level0)
2201 {
2202 int32_t userId = 1000;
2203 auto [status, cloudInfo] = cloudServiceImpl_->GetCloudInfo(userId);
2204 EXPECT_EQ(status, CloudData::CloudService::ERROR);
2205 MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
2206 delegate_.isNetworkAvailable_ = false;
2207 std::tie(status, cloudInfo) = cloudServiceImpl_->GetCloudInfo(cloudInfo_.user);
2208 EXPECT_EQ(status, CloudData::CloudService::NETWORK_ERROR);
2209 delegate_.isNetworkAvailable_ = true;
2210 }
2211
2212 /**
2213 * @tc.name: PreShare
2214 * @tc.desc: Test the PreShare with invalid parameters
2215 * @tc.type: FUNC
2216 * @tc.require:
2217 */
2218 HWTEST_F(CloudDataTest, PreShare, TestSize.Level0)
2219 {
2220 int32_t userId = 1000;
2221 StoreInfo info;
2222 info.instanceId = 0;
2223 info.bundleName = TEST_CLOUD_BUNDLE;
2224 info.storeName = TEST_CLOUD_BUNDLE;
2225 info.user = userId;
2226 StoreMetaData meta(info);
2227 meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
2228 MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta, true);
2229 DistributedRdb::RdbQuery query;
2230 auto [status, cursor] = cloudServiceImpl_->PreShare(info, query);
2231 EXPECT_EQ(status, GeneralError::E_ERROR);
2232 }
2233
2234 /**
2235 * @tc.name: InitSubTask
2236 * @tc.desc: Test the InitSubTask with invalid parameters
2237 * @tc.type: FUNC
2238 * @tc.require:
2239 */
2240 HWTEST_F(CloudDataTest, InitSubTask, TestSize.Level0)
2241 {
2242 uint64_t minInterval = 0;
2243 uint64_t expire = 24 * 60 * 60 * 1000; // 24hours, ms
2244 ExecutorPool::TaskId taskId = 100;
2245 Subscription sub;
2246 sub.expiresTime.insert_or_assign(TEST_CLOUD_BUNDLE, expire);
2247 std::shared_ptr<ExecutorPool> executor = std::move(cloudServiceImpl_->executor_);
2248 cloudServiceImpl_->executor_ = nullptr;
2249 cloudServiceImpl_->InitSubTask(sub, minInterval);
2250 EXPECT_EQ(sub.GetMinExpireTime(), expire);
2251 cloudServiceImpl_->executor_ = std::move(executor);
2252 cloudServiceImpl_->subTask_ = taskId;
2253 cloudServiceImpl_->InitSubTask(sub, minInterval);
2254 EXPECT_NE(cloudServiceImpl_->subTask_, taskId);
2255 cloudServiceImpl_->subTask_ = taskId;
2256 cloudServiceImpl_->expireTime_ = 0;
2257 cloudServiceImpl_->InitSubTask(sub, minInterval);
2258 EXPECT_EQ(cloudServiceImpl_->subTask_, taskId);
2259 cloudServiceImpl_->subTask_ = ExecutorPool::INVALID_TASK_ID;
2260 cloudServiceImpl_->InitSubTask(sub, minInterval);
2261 EXPECT_NE(cloudServiceImpl_->subTask_, ExecutorPool::INVALID_TASK_ID);
2262 }
2263
2264 /**
2265 * @tc.name: DoSubscribe
2266 * @tc.desc: Test DoSubscribe functions with invalid parameter.
2267 * @tc.type: FUNC
2268 * @tc.require:
2269 */
2270 HWTEST_F(CloudDataTest, DoSubscribe, TestSize.Level0)
2271 {
2272 Subscription sub;
2273 sub.userId = cloudInfo_.user;
2274 MetaDataManager::GetInstance().SaveMeta(sub.GetKey(), sub, true);
2275 int user = cloudInfo_.user;
2276 auto status = cloudServiceImpl_->DoSubscribe(user, CloudSyncScene::ENABLE_CLOUD);
2277 EXPECT_FALSE(status);
2278 sub.id = "testId";
2279 MetaDataManager::GetInstance().SaveMeta(sub.GetKey(), sub, true);
2280 status = cloudServiceImpl_->DoSubscribe(user, CloudSyncScene::ENABLE_CLOUD);
2281 EXPECT_FALSE(status);
2282 sub.id = TEST_CLOUD_APPID;
2283 MetaDataManager::GetInstance().SaveMeta(sub.GetKey(), sub, true);
2284 status = cloudServiceImpl_->DoSubscribe(user, CloudSyncScene::ENABLE_CLOUD);
2285 EXPECT_FALSE(status);
2286 MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
2287 status = cloudServiceImpl_->DoSubscribe(user, CloudSyncScene::ENABLE_CLOUD);
2288 EXPECT_FALSE(status);
2289 }
2290
2291 /**
2292 * @tc.name: Report
2293 * @tc.desc: Test Report.
2294 * @tc.type: FUNC
2295 * @tc.require:
2296 */
2297 HWTEST_F(CloudDataTest, Report, TestSize.Level0)
2298 {
2299 auto cloudReport = std::make_shared<DistributedData::CloudReport>();
2300 auto prepareTraceId = cloudReport->GetPrepareTraceId(100);
2301 EXPECT_EQ(prepareTraceId, "");
2302 auto requestTraceId = cloudReport->GetRequestTraceId(100);
2303 EXPECT_EQ(requestTraceId, "");
2304 ReportParam reportParam{ 100, TEST_CLOUD_BUNDLE };
2305 auto ret = cloudReport->Report(reportParam);
2306 EXPECT_TRUE(ret);
2307 }
2308
2309 /**
2310 * @tc.name: IsOn
2311 * @tc.desc: Test IsOn.
2312 * @tc.type: FUNC
2313 * @tc.require:
2314 */
2315 HWTEST_F(CloudDataTest, IsOn, TestSize.Level0)
2316 {
2317 auto cloudServerMock = std::make_shared<CloudServerMock>();
2318 auto user = AccountDelegate::GetInstance()->GetUserByToken(OHOS::IPCSkeleton::GetCallingTokenID());
2319 auto [status, cloudInfo] = cloudServerMock->GetServerInfo(user, true);
2320 int32_t instanceId = 0;
2321 auto ret = cloudInfo.IsOn("", instanceId);
2322 EXPECT_FALSE(ret);
2323 }
2324
2325 /**
2326 * @tc.name: IsAllSwitchOff
2327 * @tc.desc: Test IsAllSwitchOff.
2328 * @tc.type: FUNC
2329 * @tc.require:
2330 */
2331 HWTEST_F(CloudDataTest, IsAllSwitchOff, TestSize.Level0)
2332 {
2333 auto cloudServerMock = std::make_shared<CloudServerMock>();
2334 auto user = AccountDelegate::GetInstance()->GetUserByToken(OHOS::IPCSkeleton::GetCallingTokenID());
2335 auto [status, cloudInfo] = cloudServerMock->GetServerInfo(user, true);
2336 auto ret = cloudInfo.IsAllSwitchOff();
2337 EXPECT_FALSE(ret);
2338 }
2339
2340 /**
2341 * @tc.name: GetMinExpireTime
2342 * @tc.desc: Test GetMinExpireTime.
2343 * @tc.type: FUNC
2344 * @tc.require:
2345 */
2346 HWTEST_F(CloudDataTest, GetMinExpireTime, TestSize.Level0)
2347 {
2348 uint64_t expire = 0;
2349 Subscription sub;
2350 sub.expiresTime.insert_or_assign(TEST_CLOUD_BUNDLE, expire);
2351 sub.GetMinExpireTime();
2352 expire = 24 * 60 * 60 * 1000;
2353 sub.expiresTime.insert_or_assign(TEST_CLOUD_BUNDLE, expire);
2354 expire = 24 * 60 * 60;
2355 sub.expiresTime.insert_or_assign("test_cloud_bundleName1", expire);
2356 EXPECT_EQ(sub.GetMinExpireTime(), expire);
2357 }
2358
2359 /**
2360 * @tc.name: GetTableNames
2361 * @tc.desc: Test GetTableNames.
2362 * @tc.type: FUNC
2363 * @tc.require:
2364 */
2365 HWTEST_F(CloudDataTest, GetTableNames, TestSize.Level0)
2366 {
2367 SchemaMeta::Database database;
2368 SchemaMeta::Table table;
2369 table.name = "test_cloud_table_name";
2370 table.alias = "test_cloud_table_alias";
2371 table.sharedTableName = "test_share_table_name";
2372 database.tables.emplace_back(table);
2373 auto tableNames = database.GetTableNames();
2374 EXPECT_EQ(tableNames.size(), 2);
2375 }
2376
2377 /**
2378 * @tc.name: BlobToAssets
2379 * @tc.desc: cloud_data_translate BlobToAsset error test.
2380 * @tc.type: FUNC
2381 * @tc.require:
2382 * @tc.author: SQL
2383 */
2384 HWTEST_F(CloudDataTest, BlobToAssets, TestSize.Level1)
2385 {
2386 CloudData::RdbCloudDataTranslate rdbTranslate;
2387 DistributedDB::Asset asset = {
2388 .name = "",
2389 .assetId = "",
2390 .subpath = "",
2391 .uri = "",
2392 .modifyTime = "",
2393 .createTime = "",
2394 .size = "",
2395 .hash = ""
2396 };
2397 std::vector<uint8_t> blob;
2398 auto result = rdbTranslate.BlobToAsset(blob);
2399 EXPECT_EQ(result, asset);
2400
2401 DistributedDB::Assets assets;
2402 blob = rdbTranslate.AssetsToBlob(assets);
2403 auto results = rdbTranslate.BlobToAssets(blob);
2404 EXPECT_EQ(results, assets);
2405 }
2406
2407 /**
2408 * @tc.name: GetPriorityLevel001
2409 * @tc.desc: GetPriorityLevel test
2410 * @tc.type: FUNC
2411 * @tc.require:
2412 * @tc.author:
2413 */
2414 HWTEST_F(CloudDataTest, GetPriorityLevel001, TestSize.Level1)
2415 {
__anon572e501f0902(const Event &event) 2416 EventCenter::GetInstance().Subscribe(CloudEvent::LOCAL_CHANGE, [](const Event &event) {
2417 auto &evt = static_cast<const SyncEvent &>(event);
2418 auto mode = evt.GetMode();
2419 EXPECT_EQ(GeneralStore::GetPriorityLevel(GeneralStore::GetHighMode(static_cast<uint32_t>(mode))), 2);
2420 });
2421 DistributedRdb::RdbServiceImpl rdbServiceImpl;
2422 DistributedRdb::RdbSyncerParam param{ .bundleName_ = TEST_CLOUD_BUNDLE, .storeName_ = TEST_CLOUD_STORE };
2423 DistributedRdb::RdbService::Option option{ .mode = GeneralStore::SyncMode::CLOUD_ClOUD_FIRST, .isAsync = true };
2424 DistributedRdb::PredicatesMemo memo;
2425 memo.tables_ = { TEST_CLOUD_TABLE };
2426 rdbServiceImpl.DoCloudSync(param, option, memo, nullptr);
2427 }
2428
2429 /**
2430 * @tc.name: GetPriorityLevel002
2431 * @tc.desc: GetPriorityLevel test
2432 * @tc.type: FUNC
2433 * @tc.require:
2434 * @tc.author:
2435 */
2436 HWTEST_F(CloudDataTest, GetPriorityLevel002, TestSize.Level1)
2437 {
__anon572e501f0a02(const Event &event) 2438 EventCenter::GetInstance().Subscribe(CloudEvent::LOCAL_CHANGE, [](const Event &event) {
2439 auto &evt = static_cast<const SyncEvent &>(event);
2440 auto mode = evt.GetMode();
2441 EXPECT_EQ(GeneralStore::GetPriorityLevel(GeneralStore::GetHighMode(static_cast<uint32_t>(mode))), 0);
2442 });
2443 DistributedRdb::RdbServiceImpl rdbServiceImpl;
2444 DistributedRdb::RdbSyncerParam param{ .bundleName_ = TEST_CLOUD_BUNDLE, .storeName_ = TEST_CLOUD_STORE };
2445 DistributedRdb::RdbService::Option option{ .mode = GeneralStore::SyncMode::CLOUD_TIME_FIRST, .isAsync = true };
2446 DistributedRdb::PredicatesMemo memo;
2447 memo.tables_ = { TEST_CLOUD_TABLE };
2448 rdbServiceImpl.DoCloudSync(param, option, memo, nullptr);
2449 }
2450
2451 /**
2452 * @tc.name: GetPriorityLevel003
2453 * @tc.desc: GetPriorityLevel test
2454 * @tc.type: FUNC
2455 * @tc.require:
2456 * @tc.author:
2457 */
2458 HWTEST_F(CloudDataTest, GetPriorityLevel003, TestSize.Level1)
2459 {
__anon572e501f0b02(const Event &event) 2460 EventCenter::GetInstance().Subscribe(CloudEvent::LOCAL_CHANGE, [](const Event &event) {
2461 auto &evt = static_cast<const SyncEvent &>(event);
2462 auto mode = evt.GetMode();
2463 EXPECT_EQ(GeneralStore::GetPriorityLevel(GeneralStore::GetHighMode(static_cast<uint32_t>(mode))), 0);
2464 });
2465 DistributedRdb::RdbServiceImpl rdbServiceImpl;
2466 DistributedRdb::RdbSyncerParam param{ .bundleName_ = TEST_CLOUD_BUNDLE, .storeName_ = TEST_CLOUD_STORE };
2467 DistributedRdb::RdbService::Option option{ .mode = GeneralStore::SyncMode::CLOUD_ClOUD_FIRST, .isAsync = true };
2468 DistributedRdb::PredicatesMemo memo;
2469 rdbServiceImpl.DoCloudSync(param, option, memo, nullptr);
2470 }
2471
2472 /**
2473 * @tc.name: GetPriorityLevel004
2474 * @tc.desc: GetPriorityLevel test
2475 * @tc.type: FUNC
2476 * @tc.require:
2477 * @tc.author:
2478 */
2479 HWTEST_F(CloudDataTest, GetPriorityLevel004, TestSize.Level1)
2480 {
__anon572e501f0c02(const Event &event) 2481 EventCenter::GetInstance().Subscribe(CloudEvent::LOCAL_CHANGE, [](const Event &event) {
2482 auto &evt = static_cast<const SyncEvent &>(event);
2483 auto mode = evt.GetMode();
2484 EXPECT_EQ(GeneralStore::GetPriorityLevel(GeneralStore::GetHighMode(static_cast<uint32_t>(mode))), 1);
2485 });
2486 DistributedRdb::RdbServiceImpl rdbServiceImpl;
2487 DistributedRdb::RdbSyncerParam param{ .bundleName_ = TEST_CLOUD_BUNDLE, .storeName_ = TEST_CLOUD_STORE };
2488 DistributedRdb::RdbService::Option option{ .mode = GeneralStore::SyncMode::CLOUD_ClOUD_FIRST,
2489 .seqNum = 0,
2490 .isAsync = true,
2491 .isAutoSync = true };
2492 DistributedRdb::PredicatesMemo memo;
2493 rdbServiceImpl.DoCloudSync(param, option, memo, nullptr);
2494 }
2495
2496 /**
2497 * @tc.name: GetPrepareTraceId
2498 * @tc.desc: Test GetPrepareTraceId && GetUser
2499 * @tc.type: FUNC
2500 * @tc.require:
2501 */
2502 HWTEST_F(CloudDataTest, GetPrepareTraceId, TestSize.Level0)
2503 {
2504 SyncParam syncParam;
2505 syncParam.prepareTraceId = TEST_TRACE_ID;
2506 syncParam.user = EVT_USER;
__anon572e501f0d02(const GenDetails &details) 2507 auto async = [](const GenDetails &details) {};
2508 SyncEvent::EventInfo eventInfo(syncParam, true, nullptr, async);
2509 StoreInfo storeInfo;
2510 SyncEvent evt(storeInfo, std::move(eventInfo));
2511 EXPECT_EQ(evt.GetUser(), EVT_USER);
2512 EXPECT_EQ(evt.GetPrepareTraceId(), TEST_TRACE_ID);
2513 }
2514 } // namespace DistributedDataTest
2515 } // namespace OHOS::Test