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/cloud_mark.h"
24 #include "cloud/change_event.h"
25 #include "cloud/cloud_event.h"
26 #include "cloud/cloud_last_sync_info.h"
27 #include "cloud/cloud_report.h"
28 #include "cloud/cloud_server.h"
29 #include "cloud/cloud_share_event.h"
30 #include "cloud/make_query_event.h"
31 #include "cloud/schema_meta.h"
32 #include "cloud_data_translate.h"
33 #include "cloud_service_impl.h"
34 #include "cloud_types.h"
35 #include "cloud_types_util.h"
36 #include "cloud_value_util.h"
37 #include "communicator/device_manager_adapter.h"
38 #include "device_matrix.h"
39 #include "eventcenter/event_center.h"
40 #include "feature/feature_system.h"
41 #include "ipc_skeleton.h"
42 #include "log_print.h"
43 #include "metadata/meta_data_manager.h"
44 #include "metadata/store_meta_data.h"
45 #include "metadata/store_meta_data_local.h"
46 #include "mock/db_store_mock.h"
47 #include "mock/general_store_mock.h"
48 #include "network/network_delegate.h"
49 #include "network_delegate_mock.h"
50 #include "rdb_query.h"
51 #include "rdb_service.h"
52 #include "rdb_service_impl.h"
53 #include "rdb_types.h"
54 #include "store/auto_cache.h"
55 #include "store/general_value.h"
56 #include "store/store_info.h"
57 #include "sync_manager.h"
58 #include "token_setproc.h"
59
60 using namespace testing::ext;
61 using namespace OHOS::DistributedData;
62 using namespace OHOS::Security::AccessToken;
63 using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter;
64 using Querykey = OHOS::CloudData::QueryKey;
65 using QueryLastResults = OHOS::CloudData::QueryLastResults;
66 using CloudSyncInfo = OHOS::CloudData::CloudSyncInfo;
67 using SharingCfm = OHOS::CloudData::SharingUtil::SharingCfm;
68 using Confirmation = OHOS::CloudData::Confirmation;
69 using CenterCode = OHOS::DistributedData::SharingCenter::SharingCode;
70 using Status = OHOS::CloudData::CloudService::Status;
71 using CloudSyncScene = OHOS::CloudData::CloudServiceImpl::CloudSyncScene;
72 using GenErr = OHOS::DistributedData::GeneralError;
73 uint64_t g_selfTokenID = 0;
74
AllocHapToken(const HapPolicyParams & policy)75 void AllocHapToken(const HapPolicyParams &policy)
76 {
77 HapInfoParams info = {
78 .userID = 100,
79 .bundleName = "test_cloud_bundleName",
80 .instIndex = 0,
81 .appIDDesc = "test_cloud_bundleName",
82 .isSystemApp = true
83 };
84 auto token = AccessTokenKit::AllocHapToken(info, policy);
85 SetSelfTokenID(token.tokenIDEx);
86 }
87
88 namespace OHOS::Test {
89 namespace DistributedDataTest {
90 static constexpr const int32_t SCHEMA_VERSION = 101;
91 static constexpr const int32_t EVT_USER = 102;
92 static constexpr const char *TEST_TRACE_ID = "123456789";
93 static constexpr const char *TEST_CLOUD_BUNDLE = "test_cloud_bundleName";
94 static constexpr const char *TEST_CLOUD_APPID = "test_cloud_appid";
95 static constexpr const char *TEST_CLOUD_STORE = "test_cloud_store";
96 static constexpr const char *TEST_CLOUD_STORE_1 = "test_cloud_store1";
97 static constexpr const char *TEST_CLOUD_ID = "test_cloud_id";
98 static constexpr const char *TEST_CLOUD_TABLE = "teat_cloud_table";
99 static constexpr const char *COM_EXAMPLE_TEST_CLOUD = "com.example.testCloud";
100 static constexpr const char *TEST_CLOUD_DATABASE_ALIAS_1 = "test_cloud_database_alias_1";
101 static constexpr const char *TEST_CLOUD_DATABASE_ALIAS_2 = "test_cloud_database_alias_2";
102 static constexpr const char *PERMISSION_CLOUDDATA_CONFIG = "ohos.permission.CLOUDDATA_CONFIG";
103 static constexpr const char *PERMISSION_GET_NETWORK_INFO = "ohos.permission.GET_NETWORK_INFO";
104 static constexpr const char *PERMISSION_DISTRIBUTED_DATASYNC = "ohos.permission.DISTRIBUTED_DATASYNC";
105 static constexpr const char *PERMISSION_ACCESS_SERVICE_DM = "ohos.permission.ACCESS_SERVICE_DM";
106 static constexpr const char *PERMISSION_MANAGE_LOCAL_ACCOUNTS = "ohos.permission.MANAGE_LOCAL_ACCOUNTS";
107 static constexpr const char *PERMISSION_GET_BUNDLE_INFO = "ohos.permission.GET_BUNDLE_INFO_PRIVILEGED";
108 static constexpr const char *TEST_CLOUD_PATH =
109 "/data/app/el2/100/database/test_cloud_bundleName/entry/rdb/test_cloud_store";
GetPermissionDef(const std::string & permission)110 PermissionDef GetPermissionDef(const std::string &permission)
111 {
112 PermissionDef def = { .permissionName = permission,
113 .bundleName = "test_cloud_bundleName",
114 .grantMode = 1,
115 .availableLevel = APL_SYSTEM_BASIC,
116 .label = "label",
117 .labelId = 1,
118 .description = "test_cloud_bundleName",
119 .descriptionId = 1 };
120 return def;
121 }
122
GetPermissionStateFull(const std::string & permission)123 PermissionStateFull GetPermissionStateFull(const std::string &permission)
124 {
125 PermissionStateFull stateFull = { .permissionName = permission,
126 .isGeneral = true,
127 .resDeviceID = { "local" },
128 .grantStatus = { PermissionState::PERMISSION_GRANTED },
129 .grantFlags = { 1 } };
130 return stateFull;
131 }
132 class CloudDataTest : public testing::Test {
133 public:
134 static void SetUpTestCase(void);
135 static void TearDownTestCase(void);
136 void SetUp();
137 void TearDown();
138
139 static SchemaMeta schemaMeta_;
140 static std::shared_ptr<CloudData::CloudServiceImpl> cloudServiceImpl_;
141
142 protected:
143 static void InitMetaData();
144 static void InitSchemaMeta();
145 static void InitCloudInfo();
146 static std::shared_ptr<DBStoreMock> dbStoreMock_;
147 static StoreMetaData metaData_;
148 static CloudInfo cloudInfo_;
149 static DistributedData::CheckerMock checker_;
150 static NetworkDelegateMock delegate_;
151 };
152
153 class CloudServerMock : public CloudServer {
154 public:
155 std::pair<int32_t, CloudInfo> GetServerInfo(int32_t userId, bool needSpaceInfo) override;
156 std::pair<int32_t, SchemaMeta> GetAppSchema(int32_t userId, const std::string &bundleName) override;
157 virtual ~CloudServerMock() = default;
158 static constexpr uint64_t REMAINSPACE = 1000;
159 static constexpr uint64_t TATALSPACE = 2000;
160 static constexpr int32_t INVALID_USER_ID = -1;
161 };
162
GetServerInfo(int32_t userId,bool needSpaceInfo)163 std::pair<int32_t, CloudInfo> CloudServerMock::GetServerInfo(int32_t userId, bool needSpaceInfo)
164 {
165 CloudInfo cloudInfo;
166 cloudInfo.user = userId;
167 cloudInfo.id = TEST_CLOUD_ID;
168 cloudInfo.remainSpace = REMAINSPACE;
169 cloudInfo.totalSpace = TATALSPACE;
170 cloudInfo.enableCloud = true;
171
172 CloudInfo::AppInfo appInfo;
173 appInfo.bundleName = TEST_CLOUD_BUNDLE;
174 appInfo.appId = TEST_CLOUD_APPID;
175 appInfo.version = 1;
176 appInfo.cloudSwitch = true;
177
178 cloudInfo.apps[TEST_CLOUD_BUNDLE] = std::move(appInfo);
179 return { E_OK, cloudInfo };
180 }
181
GetAppSchema(int32_t userId,const std::string & bundleName)182 std::pair<int32_t, SchemaMeta> CloudServerMock::GetAppSchema(int32_t userId, const std::string &bundleName)
183 {
184 if (userId == INVALID_USER_ID) {
185 return { E_ERROR, CloudDataTest::schemaMeta_ };
186 }
187
188 if (bundleName.empty()) {
189 SchemaMeta schemaMeta;
190 return { E_OK, schemaMeta };
191 }
192 return { E_OK, CloudDataTest::schemaMeta_ };
193 }
194
195 std::shared_ptr<DBStoreMock> CloudDataTest::dbStoreMock_ = std::make_shared<DBStoreMock>();
196 SchemaMeta CloudDataTest::schemaMeta_;
197 StoreMetaData CloudDataTest::metaData_;
198 CloudInfo CloudDataTest::cloudInfo_;
199 std::shared_ptr<CloudData::CloudServiceImpl> CloudDataTest::cloudServiceImpl_ =
200 std::make_shared<CloudData::CloudServiceImpl>();
201 DistributedData::CheckerMock CloudDataTest::checker_;
202 NetworkDelegateMock CloudDataTest::delegate_;
203
InitMetaData()204 void CloudDataTest::InitMetaData()
205 {
206 metaData_.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
207 metaData_.appId = TEST_CLOUD_APPID;
208 metaData_.bundleName = TEST_CLOUD_BUNDLE;
209 metaData_.tokenId = OHOS::IPCSkeleton::GetCallingTokenID();
210 metaData_.user = std::to_string(AccountDelegate::GetInstance()->GetUserByToken(metaData_.tokenId));
211 metaData_.area = OHOS::DistributedKv::EL1;
212 metaData_.instanceId = 0;
213 metaData_.isAutoSync = true;
214 metaData_.storeType = DistributedRdb::RDB_DEVICE_COLLABORATION;
215 metaData_.storeId = TEST_CLOUD_STORE;
216 metaData_.dataDir = TEST_CLOUD_PATH;
217 PolicyValue value;
218 value.type = OHOS::DistributedKv::PolicyType::IMMEDIATE_SYNC_ON_ONLINE;
219 }
220
InitSchemaMeta()221 void CloudDataTest::InitSchemaMeta()
222 {
223 SchemaMeta::Field field1;
224 field1.colName = "test_cloud_field_name1";
225 field1.alias = "test_cloud_field_alias1";
226 SchemaMeta::Field field2;
227 field2.colName = "test_cloud_field_name2";
228 field2.alias = "test_cloud_field_alias2";
229
230 SchemaMeta::Table table;
231 table.name = "test_cloud_table_name";
232 table.alias = "test_cloud_table_alias";
233 table.fields.emplace_back(field1);
234 table.fields.emplace_back(field2);
235
236 SchemaMeta::Database database;
237 database.name = TEST_CLOUD_STORE;
238 database.alias = TEST_CLOUD_DATABASE_ALIAS_1;
239 database.tables.emplace_back(table);
240
241 schemaMeta_.version = 1;
242 schemaMeta_.bundleName = TEST_CLOUD_BUNDLE;
243 schemaMeta_.databases.emplace_back(database);
244 database.alias = TEST_CLOUD_DATABASE_ALIAS_2;
245 schemaMeta_.databases.emplace_back(database);
246 schemaMeta_.e2eeEnable = false;
247 }
248
InitCloudInfo()249 void CloudDataTest::InitCloudInfo()
250 {
251 cloudInfo_.user = AccountDelegate::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID());
252 cloudInfo_.id = TEST_CLOUD_ID;
253 cloudInfo_.enableCloud = true;
254
255 CloudInfo::AppInfo appInfo;
256 appInfo.bundleName = TEST_CLOUD_BUNDLE;
257 appInfo.appId = TEST_CLOUD_APPID;
258 appInfo.version = 1;
259 appInfo.cloudSwitch = true;
260
261 cloudInfo_.apps[TEST_CLOUD_BUNDLE] = std::move(appInfo);
262 }
263
SetUpTestCase(void)264 void CloudDataTest::SetUpTestCase(void)
265 {
266 MetaDataManager::GetInstance().Initialize(dbStoreMock_, nullptr, "");
267 MetaDataManager::GetInstance().SetSyncer([](const auto &, auto) {
268 DeviceMatrix::GetInstance().OnChanged(DeviceMatrix::META_STORE_MASK);
269 });
270
271 auto cloudServerMock = new CloudServerMock();
272 CloudServer::RegisterCloudInstance(cloudServerMock);
273 HapPolicyParams policy = { .apl = APL_SYSTEM_BASIC,
274 .domain = "test.domain",
275 .permList = { GetPermissionDef(PERMISSION_CLOUDDATA_CONFIG), GetPermissionDef(PERMISSION_GET_NETWORK_INFO),
276 GetPermissionDef(PERMISSION_DISTRIBUTED_DATASYNC), GetPermissionDef(PERMISSION_ACCESS_SERVICE_DM),
277 GetPermissionDef(PERMISSION_MANAGE_LOCAL_ACCOUNTS), GetPermissionDef(PERMISSION_GET_BUNDLE_INFO) },
278 .permStateList = { GetPermissionStateFull(PERMISSION_CLOUDDATA_CONFIG),
279 GetPermissionStateFull(PERMISSION_GET_NETWORK_INFO),
280 GetPermissionStateFull(PERMISSION_DISTRIBUTED_DATASYNC),
281 GetPermissionStateFull(PERMISSION_ACCESS_SERVICE_DM),
282 GetPermissionStateFull(PERMISSION_MANAGE_LOCAL_ACCOUNTS),
283 GetPermissionStateFull(PERMISSION_GET_BUNDLE_INFO)} };
284 g_selfTokenID = GetSelfTokenID();
285 AllocHapToken(policy);
286 size_t max = 12;
287 size_t min = 5;
288
289 auto executor = std::make_shared<ExecutorPool>(max, min);
290 cloudServiceImpl_->OnBind(
291 { "CloudDataTest", static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID()), std::move(executor) });
292 Bootstrap::GetInstance().LoadCheckers();
293 auto dmExecutor = std::make_shared<ExecutorPool>(max, min);
294 DeviceManagerAdapter::GetInstance().Init(dmExecutor);
295 NetworkDelegate::RegisterNetworkInstance(&delegate_);
296 InitCloudInfo();
297 InitMetaData();
298 InitSchemaMeta();
299 }
300
TearDownTestCase()301 void CloudDataTest::TearDownTestCase()
302 {
303 SetSelfTokenID(g_selfTokenID);
304 }
305
SetUp()306 void CloudDataTest::SetUp()
307 {
308 MetaDataManager::GetInstance().SaveMeta(cloudInfo_.GetKey(), cloudInfo_, true);
309 MetaDataManager::GetInstance().SaveMeta(metaData_.GetKey(), metaData_, true);
310 StoreMetaMapping storeMetaMapping(metaData_);
311 MetaDataManager::GetInstance().SaveMeta(storeMetaMapping.GetKey(), storeMetaMapping, true);
312 MetaDataManager::GetInstance().SaveMeta(cloudInfo_.GetSchemaKey(TEST_CLOUD_BUNDLE), schemaMeta_, true);
313 }
314
TearDown()315 void CloudDataTest::TearDown()
316 {
317 EventCenter::GetInstance().Unsubscribe(CloudEvent::LOCAL_CHANGE);
318 MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
319 MetaDataManager::GetInstance().DelMeta(metaData_.GetKey(), true);
320 StoreMetaMapping storeMetaMapping(metaData_);
321 MetaDataManager::GetInstance().DelMeta(storeMetaMapping.GetKey(), true);
322 MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetSchemaKey(TEST_CLOUD_BUNDLE), true);
323 }
324
325 /**
326 * @tc.name: GetSchema
327 * @tc.desc: GetSchema from cloud when no schema in meta.
328 * @tc.type: FUNC
329 * @tc.require:
330 * @tc.author: ht
331 */
332 HWTEST_F(CloudDataTest, GetSchema, TestSize.Level1)
333 {
334 auto cloudServerMock = std::make_shared<CloudServerMock>();
335 auto user = AccountDelegate::GetInstance()->GetUserByToken(OHOS::IPCSkeleton::GetCallingTokenID());
336 auto [status, cloudInfo] = cloudServerMock->GetServerInfo(user, true);
337 ASSERT_TRUE(MetaDataManager::GetInstance().DelMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE), true));
338 SchemaMeta schemaMeta;
339 ASSERT_FALSE(MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE), schemaMeta, true));
340 StoreInfo storeInfo{ OHOS::IPCSkeleton::GetCallingTokenID(), TEST_CLOUD_BUNDLE, TEST_CLOUD_STORE, 0 };
341 auto event = std::make_unique<CloudEvent>(CloudEvent::GET_SCHEMA, storeInfo);
342 EventCenter::GetInstance().PostEvent(std::move(event));
343 auto ret = MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE), schemaMeta, true);
344 ASSERT_TRUE(ret);
345 }
346
347 /**
348 * @tc.name: QueryStatistics
349 * @tc.desc: The query interface failed because cloudInfo could not be found from the metadata.
350 * @tc.type: FUNC
351 * @tc.require:
352 */
353 HWTEST_F(CloudDataTest, QueryStatistics001, TestSize.Level0)
354 {
355 // prepare MetaDta
356 MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
357
358 auto [status, result] = cloudServiceImpl_->QueryStatistics(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, "");
359 EXPECT_EQ(status, CloudData::CloudService::ERROR);
360 EXPECT_TRUE(result.empty());
361 }
362
363 /**
364 * @tc.name: QueryStatistics
365 * @tc.desc: The query interface failed because SchemaMeta could not be found from the metadata.
366 * @tc.type: FUNC
367 * @tc.require:
368 */
369 HWTEST_F(CloudDataTest, QueryStatistics002, TestSize.Level0)
370 {
371 // prepare MetaDta
372 MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetSchemaKey(TEST_CLOUD_BUNDLE), true);
373 MetaDataManager::GetInstance().SaveMeta(cloudInfo_.GetKey(), cloudInfo_, true);
374
375 auto [status, result] = cloudServiceImpl_->QueryStatistics("", "", "");
376 EXPECT_EQ(status, CloudData::CloudService::ERROR);
377 EXPECT_TRUE(result.empty());
378 std::tie(status, result) = cloudServiceImpl_->QueryStatistics(TEST_CLOUD_ID, "", "");
379 EXPECT_EQ(status, CloudData::CloudService::ERROR);
380 EXPECT_TRUE(result.empty());
381 std::tie(status, result) = cloudServiceImpl_->QueryStatistics(TEST_CLOUD_ID, TEST_CLOUD_STORE, "");
382 EXPECT_EQ(status, CloudData::CloudService::ERROR);
383 EXPECT_TRUE(result.empty());
384 std::tie(status, result) = cloudServiceImpl_->QueryStatistics(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, "");
385 EXPECT_EQ(status, CloudData::CloudService::ERROR);
386 EXPECT_TRUE(result.empty());
387 }
388
389 /**
390 * @tc.name: QueryStatistics
391 * @tc.desc: Query the statistics of cloud records in a specified database.
392 * @tc.type: FUNC
393 * @tc.require:
394 */
395 HWTEST_F(CloudDataTest, QueryStatistics003, TestSize.Level1)
396 {
397 // Construct the statisticInfo data
__anonb11b2c810202(const StoreMetaData &metaData) 398 auto creator = [](const StoreMetaData &metaData) -> GeneralStore* {
399 auto store = new (std::nothrow) GeneralStoreMock();
400 if (store != nullptr) {
401 std::map<std::string, Value> entry = { { "inserted", 1 }, { "updated", 2 }, { "normal", 3 } };
402 store->MakeCursor(entry);
403 store->SetEqualIdentifier("", "");
404 }
405 return store;
406 };
407 AutoCache::GetInstance().RegCreator(DistributedRdb::RDB_DEVICE_COLLABORATION, creator);
408
409 auto [status, result] =
410 cloudServiceImpl_->QueryStatistics(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
411 ASSERT_EQ(status, CloudData::CloudService::SUCCESS);
412 ASSERT_EQ(result.size(), 1);
413 for (const auto &it : result) {
414 ASSERT_EQ(it.first, TEST_CLOUD_DATABASE_ALIAS_1);
415 auto statisticInfos = it.second;
416 ASSERT_FALSE(statisticInfos.empty());
417 for (const auto &info : statisticInfos) {
418 EXPECT_EQ(info.inserted, 1);
419 EXPECT_EQ(info.updated, 2);
420 EXPECT_EQ(info.normal, 3);
421 }
422 }
423 }
424
425 /**
426 * @tc.name: QueryStatistics
427 * @tc.desc: Query the statistics of all local database cloud records.
428 * @tc.type: FUNC
429 * @tc.require:
430 */
431 HWTEST_F(CloudDataTest, QueryStatistics004, TestSize.Level1)
432 {
433 // Construct the statisticInfo data
__anonb11b2c810302(const StoreMetaData &metaData) 434 auto creator = [](const StoreMetaData &metaData) -> GeneralStore* {
435 auto store = new (std::nothrow) GeneralStoreMock();
436 if (store != nullptr) {
437 std::map<std::string, Value> entry = { { "inserted", 1 }, { "updated", 2 }, { "normal", 3 } };
438 store->MakeCursor(entry);
439 }
440 return store;
441 };
442 AutoCache::GetInstance().RegCreator(DistributedRdb::RDB_DEVICE_COLLABORATION, creator);
443
444 auto [status, result] = cloudServiceImpl_->QueryStatistics(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, "");
445 ASSERT_EQ(status, CloudData::CloudService::SUCCESS);
446 ASSERT_EQ(result.size(), 2);
447 for (const auto &it : result) {
448 auto statisticInfos = it.second;
449 ASSERT_FALSE(statisticInfos.empty());
450 for (const auto &info : statisticInfos) {
451 EXPECT_EQ(info.inserted, 1);
452 EXPECT_EQ(info.updated, 2);
453 EXPECT_EQ(info.normal, 3);
454 }
455 }
456 }
457
458 /**
459 * @tc.name: QueryLastSyncInfo001
460 * @tc.desc: The query last sync info interface failed because account is false.
461 * @tc.type: FUNC
462 * @tc.require:
463 */
464 HWTEST_F(CloudDataTest, QueryLastSyncInfo001, TestSize.Level0)
465 {
466 auto [status, result] =
467 cloudServiceImpl_->QueryLastSyncInfo("accountId", TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
468 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
469 EXPECT_TRUE(result.empty());
470 }
471
472 /**
473 * @tc.name: QueryLastSyncInfo002
474 * @tc.desc: The query last sync info interface failed because bundleName is false.
475 * @tc.type: FUNC
476 * @tc.require:
477 */
478 HWTEST_F(CloudDataTest, QueryLastSyncInfo002, TestSize.Level0)
479 {
480 auto [status, result] =
481 cloudServiceImpl_->QueryLastSyncInfo(TEST_CLOUD_ID, "bundleName", TEST_CLOUD_DATABASE_ALIAS_1);
482 EXPECT_EQ(status, CloudData::CloudService::Status::INVALID_ARGUMENT);
483 EXPECT_TRUE(result.empty());
484 }
485
486 /**
487 * @tc.name: QueryLastSyncInfo003
488 * @tc.desc: The query last sync info interface failed because storeId is false.
489 * @tc.type: FUNC
490 * @tc.require:
491 */
492 HWTEST_F(CloudDataTest, QueryLastSyncInfo003, TestSize.Level0)
493 {
494 auto [status, result] = cloudServiceImpl_->QueryLastSyncInfo(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, "storeId");
495 EXPECT_EQ(status, CloudData::CloudService::INVALID_ARGUMENT);
496 EXPECT_TRUE(result.empty());
497 }
498
499 /**
500 * @tc.name: QueryLastSyncInfo004
501 * @tc.desc: The query last sync info interface
502 * @tc.type: FUNC
503 * @tc.require:
504 */
505 HWTEST_F(CloudDataTest, QueryLastSyncInfo004, TestSize.Level1)
506 {
507 auto ret = cloudServiceImpl_->DisableCloud(TEST_CLOUD_ID);
508 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
509 auto user = AccountDelegate::GetInstance()->GetUserByToken(OHOS::IPCSkeleton::GetCallingTokenID());
510 cloudServiceImpl_->OnUserChange(
511 static_cast<uint32_t>(AccountStatus::DEVICE_ACCOUNT_SWITCHED), std::to_string(user), "accountId");
512
513 sleep(1);
514
515 auto [status, result] =
516 cloudServiceImpl_->QueryLastSyncInfo(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
517 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
518 EXPECT_TRUE(!result.empty());
519 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].code == E_BLOCKED_BY_NETWORK_STRATEGY);
520 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].startTime != 0);
521 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].finishTime != 0);
522 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].syncStatus == 1);
523 }
524
525 /**
526 * @tc.name: QueryLastSyncInfo005
527 * @tc.desc: The query last sync info interface
528 * @tc.type: FUNC
529 * @tc.require:
530 */
531 HWTEST_F(CloudDataTest, QueryLastSyncInfo005, TestSize.Level1)
532 {
533 std::map<std::string, int32_t> switches;
534 switches.emplace(TEST_CLOUD_ID, true);
535 CloudInfo info;
536 MetaDataManager::GetInstance().LoadMeta(cloudInfo_.GetKey(), info, true);
537 info.apps[TEST_CLOUD_BUNDLE].cloudSwitch = false;
538 MetaDataManager::GetInstance().SaveMeta(info.GetKey(), info, true);
539 auto user = AccountDelegate::GetInstance()->GetUserByToken(OHOS::IPCSkeleton::GetCallingTokenID());
540 cloudServiceImpl_->OnUserChange(
541 static_cast<uint32_t>(AccountStatus::DEVICE_ACCOUNT_SWITCHED), std::to_string(user), "accountId");
542 sleep(1);
543
544 auto [status, result] =
545 cloudServiceImpl_->QueryLastSyncInfo(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
546 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
547 EXPECT_TRUE(!result.empty());
548 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].code == E_BLOCKED_BY_NETWORK_STRATEGY);
549 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].startTime != 0);
550 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].finishTime != 0);
551 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].syncStatus == 1);
552 }
553
554 /**
555 * @tc.name: QueryLastSyncInfo006
556 * @tc.desc: The query last sync info interface
557 * @tc.type: FUNC
558 * @tc.require:
559 */
560 HWTEST_F(CloudDataTest, QueryLastSyncInfo006, TestSize.Level0)
561 {
562 MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetSchemaKey(TEST_CLOUD_BUNDLE), true);
563 auto [status, result] =
564 cloudServiceImpl_->QueryLastSyncInfo(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
565 EXPECT_EQ(status, CloudData::CloudService::ERROR);
566 EXPECT_TRUE(result.empty());
567 SchemaMeta meta;
568 meta.bundleName = "test";
569 MetaDataManager::GetInstance().SaveMeta(cloudInfo_.GetSchemaKey(TEST_CLOUD_BUNDLE), meta, true);
570 std::tie(status, result) =
571 cloudServiceImpl_->QueryLastSyncInfo(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
572 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
573 EXPECT_TRUE(result.empty());
574 }
575
576 /**
577 * @tc.name: QueryLastSyncInfo007
578 * @tc.desc: The query last sync info interface
579 * @tc.type: FUNC
580 * @tc.require:
581 */
582 HWTEST_F(CloudDataTest, QueryLastSyncInfo007, TestSize.Level0)
583 {
584 int32_t user = 100;
585 int64_t startTime = 123456789;
586 int64_t finishTime = 123456799;
587 CloudLastSyncInfo lastSyncInfo;
588 lastSyncInfo.id = TEST_CLOUD_ID;
589 lastSyncInfo.storeId = TEST_CLOUD_DATABASE_ALIAS_1;
590 lastSyncInfo.startTime = startTime;
591 lastSyncInfo.finishTime = finishTime;
592 lastSyncInfo.syncStatus = 1;
593 MetaDataManager::GetInstance().SaveMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
594 TEST_CLOUD_DATABASE_ALIAS_1), lastSyncInfo, true);
595
596 std::vector<CloudLastSyncInfo> lastSyncInfos;
597 MetaDataManager::GetInstance().LoadMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
598 TEST_CLOUD_DATABASE_ALIAS_1), lastSyncInfos, true);
599 EXPECT_TRUE(!lastSyncInfos.empty());
600
601 CloudData::SyncManager sync;
602 auto [status, result] = sync.QueryLastSyncInfo({ { user, TEST_CLOUD_ID, TEST_CLOUD_BUNDLE,
603 TEST_CLOUD_DATABASE_ALIAS_1 } });
604 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
605 EXPECT_TRUE(!result.empty());
606 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].code == -1);
607 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].startTime == startTime);
608 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].finishTime == finishTime);
609 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].syncStatus == 1);
610 }
611
612 /**
613 * @tc.name: QueryLastSyncInfo008
614 * @tc.desc: The query last sync info interface
615 * @tc.type: FUNC
616 * @tc.require:
617 */
618 HWTEST_F(CloudDataTest, QueryLastSyncInfo008, TestSize.Level0)
619 {
620 int32_t user = 100;
621 int64_t startTime = 123456789;
622 int64_t finishTime = 123456799;
623 CloudLastSyncInfo lastSyncInfo;
624 lastSyncInfo.id = TEST_CLOUD_ID;
625 lastSyncInfo.storeId = TEST_CLOUD_DATABASE_ALIAS_1;
626 lastSyncInfo.startTime = startTime;
627 lastSyncInfo.finishTime = finishTime;
628 lastSyncInfo.syncStatus = 1;
629 lastSyncInfo.code = 0;
630 MetaDataManager::GetInstance().SaveMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
631 TEST_CLOUD_DATABASE_ALIAS_1), lastSyncInfo, true);
632 CloudLastSyncInfo lastSyncInfo1;
633 lastSyncInfo1.id = TEST_CLOUD_ID;
634 lastSyncInfo1.storeId = TEST_CLOUD_DATABASE_ALIAS_2;
635 lastSyncInfo1.startTime = startTime;
636 lastSyncInfo1.finishTime = finishTime;
637 lastSyncInfo1.syncStatus = 1;
638 lastSyncInfo1.code = 0;
639 MetaDataManager::GetInstance().SaveMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
640 TEST_CLOUD_DATABASE_ALIAS_2), lastSyncInfo1, true);
641
642 std::vector<CloudLastSyncInfo> lastSyncInfos;
643 MetaDataManager::GetInstance().LoadMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
644 ""), lastSyncInfos, true);
645 EXPECT_TRUE(!lastSyncInfos.empty());
646
647 CloudData::SyncManager sync;
648 auto [status, result] = sync.QueryLastSyncInfo({ { user, TEST_CLOUD_ID, TEST_CLOUD_BUNDLE,
649 TEST_CLOUD_DATABASE_ALIAS_1 }, { user, TEST_CLOUD_ID, TEST_CLOUD_BUNDLE,
650 TEST_CLOUD_DATABASE_ALIAS_2} });
651
652 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
653 EXPECT_TRUE(result.size() == 2);
654 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].code == 0);
655 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].startTime == startTime);
656 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].finishTime == finishTime);
657 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].syncStatus == 1);
658
659 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_2].code == 0);
660 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_2].startTime == startTime);
661 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_2].finishTime == finishTime);
662 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_2].syncStatus == 1);
663 }
664
665 /**
666 * @tc.name: QueryLastSyncInfo009
667 * @tc.desc: The query last sync info interface failed when schema is invalid.
668 * @tc.type: FUNC
669 * @tc.require:
670 */
671 HWTEST_F(CloudDataTest, QueryLastSyncInfo009, TestSize.Level0)
672 {
673 int32_t user = 100;
674 int64_t startTime = 123456789;
675 int64_t finishTime = 123456799;
676 CloudLastSyncInfo lastSyncInfo;
677 lastSyncInfo.id = TEST_CLOUD_ID;
678 lastSyncInfo.storeId = TEST_CLOUD_DATABASE_ALIAS_1;
679 lastSyncInfo.startTime = startTime;
680 lastSyncInfo.finishTime = finishTime;
681 lastSyncInfo.syncStatus = 1;
682 lastSyncInfo.code = 0;
683 MetaDataManager::GetInstance().SaveMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
684 TEST_CLOUD_DATABASE_ALIAS_1), lastSyncInfo, true);
685 CloudLastSyncInfo lastSyncInfo1;
686 lastSyncInfo1.id = TEST_CLOUD_ID;
687 lastSyncInfo1.storeId = TEST_CLOUD_DATABASE_ALIAS_2;
688 lastSyncInfo1.startTime = startTime;
689 lastSyncInfo1.finishTime = finishTime;
690 lastSyncInfo1.syncStatus = 1;
691 lastSyncInfo1.code = 0;
692 MetaDataManager::GetInstance().SaveMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
693 TEST_CLOUD_DATABASE_ALIAS_2), lastSyncInfo1, true);
694
695 std::vector<CloudLastSyncInfo> lastSyncInfos;
696 MetaDataManager::GetInstance().LoadMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE, ""),
697 lastSyncInfos, true);
698 EXPECT_TRUE(!lastSyncInfos.empty());
699
700 CloudData::SyncManager sync;
701 auto [status, result] = sync.QueryLastSyncInfo({ { user, TEST_CLOUD_ID, TEST_CLOUD_BUNDLE,
702 TEST_CLOUD_DATABASE_ALIAS_2} });
703 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
704 EXPECT_TRUE(result.size() == 1);
705 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_2].code == 0);
706 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_2].startTime == startTime);
707 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_2].finishTime == finishTime);
708 EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_2].syncStatus == 1);
709 }
710
711 /**
712 * @tc.name: QueryLastSyncInfo010
713 * @tc.desc: The query last sync info interface failed
714 * @tc.type: FUNC
715 * @tc.require:
716 */
717 HWTEST_F(CloudDataTest, QueryLastSyncInfo010, TestSize.Level0)
718 {
719 int32_t user = 100;
720 int64_t startTime = 123456789;
721 int64_t finishTime = 123456799;
722 CloudLastSyncInfo lastSyncInfo;
723 lastSyncInfo.id = TEST_CLOUD_ID;
724 lastSyncInfo.storeId = TEST_CLOUD_DATABASE_ALIAS_1;
725 lastSyncInfo.startTime = startTime;
726 lastSyncInfo.finishTime = finishTime;
727 lastSyncInfo.syncStatus = 1;
728 lastSyncInfo.code = 0;
729 MetaDataManager::GetInstance().SaveMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
730 TEST_CLOUD_DATABASE_ALIAS_1), lastSyncInfo, true);
731 CloudLastSyncInfo lastSyncInfo1;
732 lastSyncInfo1.id = TEST_CLOUD_ID;
733 lastSyncInfo1.storeId = TEST_CLOUD_DATABASE_ALIAS_2;
734 lastSyncInfo1.startTime = startTime;
735 lastSyncInfo1.finishTime = finishTime;
736 lastSyncInfo1.syncStatus = 1;
737 lastSyncInfo1.code = 0;
738 MetaDataManager::GetInstance().SaveMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
739 TEST_CLOUD_DATABASE_ALIAS_2), lastSyncInfo1, true);
740
741 CloudData::SyncManager sync;
742 CloudData::SyncManager::SyncInfo info(user, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
743 auto [status, result] = sync.QueryLastSyncInfo({ { user, TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, "1234"} });
744 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
745 EXPECT_TRUE(result.empty());
746 }
747
748 /**
749 * @tc.name: QueryLastSyncInfo011
750 * @tc.desc: The query last sync info interface
751 * @tc.type: FUNC
752 * @tc.require:
753 */
754 HWTEST_F(CloudDataTest, QueryLastSyncInfo011, TestSize.Level1)
755 {
756 schemaMeta_.databases[1].name = TEST_CLOUD_STORE_1;
757 MetaDataManager::GetInstance().SaveMeta(cloudInfo_.GetSchemaKey(TEST_CLOUD_BUNDLE), schemaMeta_, true);
758 int32_t user = 100;
759 CloudData::SyncManager sync;
760 CloudData::SyncManager::SyncInfo info(user, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
761 info.syncId_ = 0;
762 CloudInfo cloud;
763 cloud.user = info.user_;
764 auto cloudSyncInfos = sync.GetCloudSyncInfo(info, cloud);
765 sync.UpdateStartSyncInfo(cloudSyncInfos);
766 auto [status, result] = sync.QueryLastSyncInfo({ { user, TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_STORE },
767 { user, TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_STORE_1} });
768 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
769 EXPECT_TRUE(result.size() == 2);
770 EXPECT_TRUE(result[TEST_CLOUD_STORE].code == 0);
771 EXPECT_TRUE(result[TEST_CLOUD_STORE].startTime != 0);
772 EXPECT_TRUE(result[TEST_CLOUD_STORE].finishTime == 0);
773 EXPECT_TRUE(result[TEST_CLOUD_STORE].syncStatus == 0);
774
775 EXPECT_TRUE(result[TEST_CLOUD_STORE_1].code == 0);
776 EXPECT_TRUE(result[TEST_CLOUD_STORE_1].startTime != 0);
777 EXPECT_TRUE(result[TEST_CLOUD_STORE_1].finishTime == 0);
778 EXPECT_TRUE(result[TEST_CLOUD_STORE_1].syncStatus == 0);
779 }
780
781 /**
782 * @tc.name: QueryLastSyncInfo012
783 * @tc.desc: The query last sync info interface failed.
784 * @tc.type: FUNC
785 * @tc.require:
786 */
787 HWTEST_F(CloudDataTest, QueryLastSyncInfo012, TestSize.Level0)
788 {
789 int32_t user = 100;
790 int64_t startTime = 123456789;
791 int64_t finishTime = 123456799;
792 CloudLastSyncInfo lastSyncInfo;
793 lastSyncInfo.id = TEST_CLOUD_ID;
794 lastSyncInfo.storeId = TEST_CLOUD_DATABASE_ALIAS_1;
795 lastSyncInfo.startTime = startTime;
796 lastSyncInfo.finishTime = finishTime;
797 lastSyncInfo.syncStatus = 1;
798 MetaDataManager::GetInstance().SaveMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
799 TEST_CLOUD_DATABASE_ALIAS_1), lastSyncInfo, true);
800
801 std::vector<CloudLastSyncInfo> lastSyncInfos;
802 MetaDataManager::GetInstance().LoadMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
803 TEST_CLOUD_DATABASE_ALIAS_1), lastSyncInfos, true);
804 EXPECT_TRUE(!lastSyncInfos.empty());
805
806 CloudData::SyncManager sync;
807 CloudData::SyncManager::SyncInfo info(user, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
808 auto [status, result] = sync.QueryLastSyncInfo({ { user, TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, "1234"} });
809 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
810 EXPECT_TRUE(result.empty());
811 }
812
813 /**
814 * @tc.name: GetStores
815 * @tc.desc: Test GetStores function
816 * @tc.type: FUNC
817 * @tc.require:
818 */
819 HWTEST_F(CloudDataTest, GetStores, TestSize.Level0)
820 {
821 auto cloudServerMock = std::make_shared<CloudServerMock>();
822 auto user = AccountDelegate::GetInstance()->GetUserByToken(OHOS::IPCSkeleton::GetCallingTokenID());
823 auto [status, cloudInfo] = cloudServerMock->GetServerInfo(user, true);
824 SchemaMeta schemaMeta;
825 MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE), schemaMeta, true);
826 EXPECT_TRUE(!schemaMeta.GetStores().empty());
827 }
828
829 /**
830 * @tc.name: UpdateStartSyncInfo
831 * @tc.desc: Test UpdateStartSyncInfo
832 * @tc.type: FUNC
833 * @tc.require:
834 */
835 HWTEST_F(CloudDataTest, UpdateStartSyncInfo, TestSize.Level0)
836 {
837 int32_t user = 100;
838 CloudData::SyncManager sync;
839 CloudData::SyncManager::SyncInfo info(user, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
840 CloudInfo cloud;
841 cloud.user = info.user_;
842 auto cloudSyncInfos = sync.GetCloudSyncInfo(info, cloud);
843 sync.UpdateStartSyncInfo(cloudSyncInfos);
844 std::vector<CloudLastSyncInfo> lastSyncInfos;
845 MetaDataManager::GetInstance().LoadMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
846 ""), lastSyncInfos, true);
847 EXPECT_TRUE(!lastSyncInfos.empty());
848 printf("code: %d", lastSyncInfos[0].code);
849 EXPECT_TRUE(lastSyncInfos[0].code == -1);
850 EXPECT_TRUE(lastSyncInfos[0].startTime != 0);
851 EXPECT_TRUE(lastSyncInfos[0].finishTime != 0);
852 EXPECT_TRUE(lastSyncInfos[0].syncStatus == 1);
853 }
854
855 /**
856 * @tc.name: UpdateStartSyncInfo
857 * @tc.desc: Test UpdateStartSyncInfo
858 * @tc.type: FUNC
859 * @tc.require:
860 */
861 HWTEST_F(CloudDataTest, UpdateFinishSyncInfo, TestSize.Level0)
862 {
863 int32_t user = 100;
864 CloudData::SyncManager sync;
865 CloudData::SyncManager::SyncInfo info(user, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
866 CloudInfo cloud;
867 cloud.user = info.user_;
868 auto cloudSyncInfos = sync.GetCloudSyncInfo(info, cloud);
869 sync.UpdateStartSyncInfo(cloudSyncInfos);
870 sync.UpdateFinishSyncInfo({ user, TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1 }, 0, 0);
871 std::vector<CloudLastSyncInfo> lastSyncInfos;
872 MetaDataManager::GetInstance().LoadMeta(CloudLastSyncInfo::GetKey(user, TEST_CLOUD_BUNDLE,
873 ""), lastSyncInfos, true);
874 EXPECT_TRUE(!lastSyncInfos.empty());
875 }
876
877 /**
878 * @tc.name: Share
879 * @tc.desc:
880 * @tc.type: FUNC
881 * @tc.require:
882 */
883 HWTEST_F(CloudDataTest, Share001, TestSize.Level1)
884 {
885 std::string sharingRes = "";
886 CloudData::Participants participants{};
887 CloudData::Results results;
888 auto ret = cloudServiceImpl_->Share(sharingRes, participants, results);
889 EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
890 }
891
892 /**
893 * @tc.name: Unshare
894 * @tc.desc:
895 * @tc.type: FUNC
896 * @tc.require:
897 */
898 HWTEST_F(CloudDataTest, Unshare001, TestSize.Level1)
899 {
900 std::string sharingRes = "";
901 CloudData::Participants participants{};
902 CloudData::Results results;
903 auto ret = cloudServiceImpl_->Unshare(sharingRes, participants, results);
904 EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
905 }
906
907 /**
908 * @tc.name: ChangePrivilege
909 * @tc.desc:
910 * @tc.type: FUNC
911 * @tc.require:
912 */
913 HWTEST_F(CloudDataTest, ChangePrivilege001, TestSize.Level1)
914 {
915 std::string sharingRes = "";
916 CloudData::Participants participants{};
917 CloudData::Results results;
918 auto ret = cloudServiceImpl_->ChangePrivilege(sharingRes, participants, results);
919 EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
920 }
921
922 /**
923 * @tc.name: ChangeConfirmation
924 * @tc.desc:
925 * @tc.type: FUNC
926 * @tc.require:
927 */
928 HWTEST_F(CloudDataTest, ChangeConfirmation001, TestSize.Level1)
929 {
930 std::string sharingRes = "";
931 int32_t confirmation = 0;
932 std::pair<int32_t, std::string> result;
933 auto ret = cloudServiceImpl_->ChangeConfirmation(sharingRes, confirmation, result);
934 EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
935 }
936
937 /**
938 * @tc.name: ConfirmInvitation
939 * @tc.desc:
940 * @tc.type: FUNC
941 * @tc.require:
942 */
943 HWTEST_F(CloudDataTest, ConfirmInvitation001, TestSize.Level1)
944 {
945 std::string sharingRes = "";
946 int32_t confirmation = 0;
947 std::tuple<int32_t, std::string, std::string> result;
948 auto ret = cloudServiceImpl_->ConfirmInvitation(sharingRes, confirmation, result);
949 EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
950 }
951
952 /**
953 * @tc.name: Exit
954 * @tc.desc:
955 * @tc.type: FUNC
956 * @tc.require:
957 */
958 HWTEST_F(CloudDataTest, Exit001, TestSize.Level1)
959 {
960 std::string sharingRes = "";
961 std::pair<int32_t, std::string> result;
962 auto ret = cloudServiceImpl_->Exit(sharingRes, result);
963 EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
964 }
965
966 /**
967 * @tc.name: Query
968 * @tc.desc:
969 * @tc.type: FUNC
970 * @tc.require:
971 */
972 HWTEST_F(CloudDataTest, Query001, TestSize.Level1)
973 {
974 std::string sharingRes = "";
975 CloudData::QueryResults result;
976 auto ret = cloudServiceImpl_->Query(sharingRes, result);
977 EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
978 }
979
980 /**
981 * @tc.name: QueryByInvitation
982 * @tc.desc:
983 * @tc.type: FUNC
984 * @tc.require:
985 */
986 HWTEST_F(CloudDataTest, QueryByInvitation001, TestSize.Level1)
987 {
988 std::string invitation = "";
989 CloudData::QueryResults result;
990 auto ret = cloudServiceImpl_->QueryByInvitation(invitation, result);
991 EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
992 }
993
994 /**
995 * @tc.name: AllocResourceAndShare
996 * @tc.desc:
997 * @tc.type: FUNC
998 * @tc.require:
999 */
1000 HWTEST_F(CloudDataTest, AllocResourceAndShare001, TestSize.Level0)
1001 {
1002 DistributedRdb::PredicatesMemo predicates;
1003 predicates.tables_.push_back(TEST_CLOUD_BUNDLE);
1004 std::vector<std::string> columns;
1005 CloudData::Participants participants;
1006 auto [ret, _] = cloudServiceImpl_->AllocResourceAndShare(TEST_CLOUD_STORE, predicates, columns, participants);
1007 EXPECT_EQ(ret, E_ERROR);
__anonb11b2c810402(const Event &event) 1008 EventCenter::GetInstance().Subscribe(CloudEvent::MAKE_QUERY, [](const Event &event) {
1009 auto &evt = static_cast<const DistributedData::MakeQueryEvent &>(event);
1010 auto callback = evt.GetCallback();
1011 if (!callback) {
1012 return;
1013 }
1014 auto predicate = evt.GetPredicates();
1015 auto rdbQuery = std::make_shared<DistributedRdb::RdbQuery>();
1016 rdbQuery->MakeQuery(*predicate);
1017 rdbQuery->SetColumns(evt.GetColumns());
1018 callback(rdbQuery);
1019 });
1020 std::tie(ret, _) = cloudServiceImpl_->AllocResourceAndShare(TEST_CLOUD_STORE, predicates, columns, participants);
1021 EXPECT_EQ(ret, E_ERROR);
1022 }
1023
1024 /**
1025 * @tc.name: SetGlobalCloudStrategy
1026 * @tc.desc:
1027 * @tc.type: FUNC
1028 * @tc.require:
1029 */
1030 HWTEST_F(CloudDataTest, SetGlobalCloudStrategy001, TestSize.Level1)
1031 {
1032 std::vector<CommonType::Value> values;
1033 values.push_back(CloudData::NetWorkStrategy::WIFI);
1034 CloudData::Strategy strategy = CloudData::Strategy::STRATEGY_BUTT;
1035 auto ret = cloudServiceImpl_->SetGlobalCloudStrategy(strategy, values);
1036 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1037 strategy = CloudData::Strategy::STRATEGY_NETWORK;
1038 ret = cloudServiceImpl_->SetGlobalCloudStrategy(strategy, values);
1039 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1040 }
1041
1042 /**
1043 * @tc.name: SetCloudStrategy
1044 * @tc.desc:
1045 * @tc.type: FUNC
1046 * @tc.require:
1047 */
1048 HWTEST_F(CloudDataTest, SetCloudStrategy001, TestSize.Level1)
1049 {
1050 std::vector<CommonType::Value> values;
1051 values.push_back(CloudData::NetWorkStrategy::WIFI);
1052 CloudData::Strategy strategy = CloudData::Strategy::STRATEGY_BUTT;
1053 auto ret = cloudServiceImpl_->SetCloudStrategy(strategy, values);
1054 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1055 strategy = CloudData::Strategy::STRATEGY_NETWORK;
1056 ret = cloudServiceImpl_->SetCloudStrategy(strategy, values);
1057 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1058 }
1059
1060 /**
1061 * @tc.name: CloudSync001
1062 * @tc.desc:
1063 * @tc.type: FUNC
1064 * @tc.require:
1065 */
1066 HWTEST_F(CloudDataTest, CloudSync001, TestSize.Level0)
1067 {
1068 int32_t syncMode = DistributedData::GeneralStore::NEARBY_BEGIN;
1069 uint32_t seqNum = 10;
1070 // invalid syncMode
1071 auto ret = cloudServiceImpl_->CloudSync("bundleName", "storeId", { syncMode, seqNum }, nullptr);
1072 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1073 }
1074
1075 /**
1076 * @tc.name: CloudSync002
1077 * @tc.desc:
1078 * @tc.type: FUNC
1079 * @tc.require:
1080 */
1081 HWTEST_F(CloudDataTest, CloudSync002, TestSize.Level0)
1082 {
1083 int32_t syncMode = DistributedData::GeneralStore::NEARBY_PULL_PUSH;
1084 uint32_t seqNum = 10;
1085 // invalid syncMode
1086 auto ret = cloudServiceImpl_->CloudSync("bundleName", "storeId", { syncMode, seqNum }, nullptr);
1087 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1088 }
1089
1090 /**
1091 * @tc.name: CloudSync003
1092 * @tc.desc:
1093 * @tc.type: FUNC
1094 * @tc.require:
1095 */
1096 HWTEST_F(CloudDataTest, CloudSync003, TestSize.Level1)
1097 {
1098 int32_t syncMode = DistributedData::GeneralStore::CLOUD_BEGIN;
1099 uint32_t seqNum = 10;
1100 auto ret = cloudServiceImpl_->CloudSync("bundleName", "storeId", { syncMode, seqNum }, nullptr);
1101 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1102 }
1103
1104 /**
1105 * @tc.name: CloudSync004
1106 * @tc.desc:
1107 * @tc.type: FUNC
1108 * @tc.require:
1109 */
1110 HWTEST_F(CloudDataTest, CloudSync004, TestSize.Level1)
1111 {
1112 int32_t syncMode = DistributedData::GeneralStore::CLOUD_TIME_FIRST;
1113 uint32_t seqNum = 10;
1114 auto ret = cloudServiceImpl_->CloudSync("bundleName", "storeId", { syncMode, seqNum }, nullptr);
1115 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1116 }
1117
1118 /**
1119 * @tc.name: CloudSync005
1120 * @tc.desc:
1121 * @tc.type: FUNC
1122 * @tc.require:
1123 */
1124 HWTEST_F(CloudDataTest, CloudSync005, TestSize.Level1)
1125 {
1126 int32_t syncMode = DistributedData::GeneralStore::CLOUD_NATIVE_FIRST;
1127 uint32_t seqNum = 10;
1128 auto ret = cloudServiceImpl_->CloudSync("bundleName", "storeId", { syncMode, seqNum }, nullptr);
1129 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1130 }
1131
1132 /**
1133 * @tc.name: CloudSync006
1134 * @tc.desc:
1135 * @tc.type: FUNC
1136 * @tc.require:
1137 */
1138 HWTEST_F(CloudDataTest, CloudSync006, TestSize.Level1)
1139 {
1140 int32_t syncMode = DistributedData::GeneralStore::CLOUD_CLOUD_FIRST;
1141 uint32_t seqNum = 10;
1142 auto ret = cloudServiceImpl_->CloudSync("bundleName", "storeId", { syncMode, seqNum }, nullptr);
1143 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1144 }
1145
1146 /**
1147 * @tc.name: CloudSync007
1148 * @tc.desc:
1149 * @tc.type: FUNC
1150 * @tc.require:
1151 */
1152 HWTEST_F(CloudDataTest, CloudSync007, TestSize.Level0)
1153 {
1154 int32_t syncMode = DistributedData::GeneralStore::CLOUD_END;
1155 uint32_t seqNum = 10;
1156 auto ret = cloudServiceImpl_->CloudSync("bundleName", "storeId", { syncMode, seqNum }, nullptr);
1157 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1158
1159 CloudData::Details details{};
1160 uint32_t tokenId = 0;
1161 cloudServiceImpl_->OnAsyncComplete(tokenId, seqNum, std::move(details));
1162 }
1163
1164 /**
1165 * @tc.name: InitNotifier001
1166 * @tc.desc:
1167 * @tc.type: FUNC
1168 * @tc.require:
1169 */
1170 HWTEST_F(CloudDataTest, InitNotifier001, TestSize.Level0)
1171 {
1172 sptr<IRemoteObject> notifier = nullptr;
1173 auto ret = cloudServiceImpl_->InitNotifier(notifier);
1174 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1175
1176 ret = cloudServiceImpl_->InitNotifier(notifier);
1177 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1178 }
1179
1180 /**
1181 * @tc.name: Clean
1182 * @tc.desc:
1183 * @tc.type: FUNC
1184 * @tc.require:
1185 */
1186 HWTEST_F(CloudDataTest, Clean001, TestSize.Level0)
1187 {
1188 std::map<std::string, int32_t> actions;
1189 actions.insert_or_assign(TEST_CLOUD_BUNDLE, CloudData::CloudService::Action::CLEAR_CLOUD_BUTT);
1190 std::string id = "testId";
1191 std::string bundleName = "testBundleName";
1192 auto ret = cloudServiceImpl_->Clean(id, actions);
1193 EXPECT_EQ(ret, CloudData::CloudService::ERROR);
1194 ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
1195 EXPECT_EQ(ret, CloudData::CloudService::ERROR);
1196 actions.insert_or_assign(TEST_CLOUD_BUNDLE, CloudData::CloudService::Action::CLEAR_CLOUD_INFO);
1197 actions.insert_or_assign(bundleName, CloudData::CloudService::Action::CLEAR_CLOUD_DATA_AND_INFO);
1198 ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
1199 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1200 }
1201
1202 /**
1203 * @tc.name: Clean
1204 * @tc.desc:
1205 * @tc.type: FUNC
1206 * @tc.require:
1207 */
1208 HWTEST_F(CloudDataTest, Clean002, TestSize.Level0)
1209 {
1210 MetaDataManager::GetInstance().DelMeta(metaData_.GetKey(), true);
1211 std::map<std::string, int32_t> actions;
1212 actions.insert_or_assign(TEST_CLOUD_BUNDLE, CloudData::CloudService::Action::CLEAR_CLOUD_INFO);
1213 auto ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
1214 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1215 StoreMetaDataLocal localMeta;
1216 localMeta.isPublic = false;
1217 MetaDataManager::GetInstance().SaveMeta(metaData_.GetKeyLocal(), localMeta, true);
1218 ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
1219 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1220 localMeta.isPublic = true;
1221 MetaDataManager::GetInstance().SaveMeta(metaData_.GetKeyLocal(), localMeta, true);
1222 ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
1223 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1224 metaData_.user = "0";
1225 MetaDataManager::GetInstance().SaveMeta(metaData_.GetKey(), metaData_, true);
1226 ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
1227 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1228 MetaDataManager::GetInstance().DelMeta(metaData_.GetKey(), true);
1229 metaData_.user = std::to_string(AccountDelegate::GetInstance()->GetUserByToken(metaData_.tokenId));
1230 MetaDataManager::GetInstance().DelMeta(metaData_.GetKeyLocal(), true);
1231 }
1232
1233 /**
1234 * @tc.name: NotifyDataChange
1235 * @tc.desc:
1236 * @tc.type: FUNC
1237 * @tc.require:
1238 */
1239 HWTEST_F(CloudDataTest, NotifyDataChange001, TestSize.Level0)
1240 {
1241 auto ret = cloudServiceImpl_->NotifyDataChange(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE);
1242 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1243 }
1244
1245 /**
1246 * @tc.name: NotifyDataChange
1247 * @tc.desc:
1248 * @tc.type: FUNC
1249 * @tc.require:
1250 */
1251 HWTEST_F(CloudDataTest, NotifyDataChange002, TestSize.Level0)
1252 {
1253 constexpr const int32_t invalidUserId = -1;
1254 std::string extraData;
1255 auto ret = cloudServiceImpl_->NotifyDataChange("", extraData, invalidUserId);
1256 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1257 ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, invalidUserId);
1258 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1259 extraData = "{data:test}";
1260 ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, invalidUserId);
1261 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1262 extraData = "{\"data\":\"{\\\"accountId\\\":\\\"id\\\",\\\"bundleName\\\":\\\"test_cloud_"
1263 "bundleName\\\",\\\"containerName\\\":\\\"test_cloud_database_alias_1\\\", \\\"databaseScopes\\\": "
1264 "\\\"[\\\\\\\"private\\\\\\\", "
1265 "\\\\\\\"shared\\\\\\\"]\\\",\\\"recordTypes\\\":\\\"[\\\\\\\"test_cloud_table_alias\\\\\\\"]\\\"}\"}";
1266 ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, invalidUserId);
1267 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1268 extraData = "{\"data\":\"{\\\"accountId\\\":\\\"test_cloud_id\\\",\\\"bundleName\\\":\\\"cloud_"
1269 "bundleName_test\\\",\\\"containerName\\\":\\\"test_cloud_database_alias_1\\\", "
1270 "\\\"databaseScopes\\\": "
1271 "\\\"[\\\\\\\"private\\\\\\\", "
1272 "\\\\\\\"shared\\\\\\\"]\\\",\\\"recordTypes\\\":\\\"[\\\\\\\"test_cloud_table_alias\\\\\\\"]\\\"}\"}";
1273 ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, invalidUserId);
1274 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1275 }
1276
1277 /**
1278 * @tc.name: NotifyDataChange
1279 * @tc.desc:
1280 * @tc.type: FUNC
1281 * @tc.require:
1282 */
1283 HWTEST_F(CloudDataTest, NotifyDataChange003, TestSize.Level1)
1284 {
1285 constexpr const int32_t userId = 100;
1286 constexpr const int32_t defaultUserId = 0;
1287 std::string extraData = "{\"data\":\"{\\\"accountId\\\":\\\"test_cloud_id\\\",\\\"bundleName\\\":\\\"test_cloud_"
1288 "bundleName\\\",\\\"containerName\\\":\\\"test_cloud_database_alias_1\\\", "
1289 "\\\"databaseScopes\\\": "
1290 "\\\"[\\\\\\\"private\\\\\\\", "
1291 "\\\\\\\"shared\\\\\\\"]\\\",\\\"recordTypes\\\":\\\"[\\\\\\\"\\\\\\\"]\\\"}\"}";
1292 auto ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, defaultUserId);
1293 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1294 extraData = "{\"data\":\"{\\\"accountId\\\":\\\"test_cloud_id\\\",\\\"bundleName\\\":\\\"test_cloud_"
1295 "bundleName\\\",\\\"containerName\\\":\\\"test_cloud_database_alias_1\\\", \\\"databaseScopes\\\": "
1296 "\\\"[\\\\\\\"private\\\\\\\", "
1297 "\\\\\\\"shared\\\\\\\"]\\\",\\\"recordTypes\\\":\\\"[\\\\\\\"test_cloud_table_alias\\\\\\\"]\\\"}\"}";
1298 ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, userId);
1299 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1300 }
1301
1302 /**
1303 * @tc.name: Offline
1304 * @tc.desc:
1305 * @tc.type: FUNC
1306 * @tc.require:
1307 */
1308 HWTEST_F(CloudDataTest, Offline001, TestSize.Level0)
1309 {
1310 std::string device = "test";
1311 auto ret = cloudServiceImpl_->Offline(device);
1312 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1313 ret = cloudServiceImpl_->Offline(DeviceManagerAdapter::CLOUD_DEVICE_UUID);
1314 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1315 }
1316
1317 /**
1318 * @tc.name: CloudShare
1319 * @tc.desc:
1320 * @tc.type: FUNC
1321 * @tc.require:
1322 */
1323 HWTEST_F(CloudDataTest, CloudShare001, TestSize.Level0)
1324 {
1325 StoreInfo storeInfo{ OHOS::IPCSkeleton::GetCallingTokenID(), TEST_CLOUD_BUNDLE, TEST_CLOUD_STORE, 0 };
1326 std::pair<int32_t, std::shared_ptr<Cursor>> result;
__anonb11b2c810502(int32_t status, std::shared_ptr<Cursor> cursor) 1327 CloudShareEvent::Callback asyncCallback = [&result](int32_t status, std::shared_ptr<Cursor> cursor) {
1328 result.first = status;
1329 result.second = cursor;
1330 };
1331 auto event = std::make_unique<CloudShareEvent>(storeInfo, nullptr, nullptr);
1332 EventCenter::GetInstance().PostEvent(std::move(event));
1333 auto event1 = std::make_unique<CloudShareEvent>(storeInfo, nullptr, asyncCallback);
1334 EventCenter::GetInstance().PostEvent(std::move(event1));
1335 EXPECT_EQ(result.first, GeneralError::E_ERROR);
1336 auto rdbQuery = std::make_shared<DistributedRdb::RdbQuery>();
1337 auto event2 = std::make_unique<CloudShareEvent>(storeInfo, rdbQuery, nullptr);
1338 EventCenter::GetInstance().PostEvent(std::move(event2));
1339 auto event3 = std::make_unique<CloudShareEvent>(storeInfo, rdbQuery, asyncCallback);
1340 EventCenter::GetInstance().PostEvent(std::move(event3));
1341 EXPECT_EQ(result.first, GeneralError::E_ERROR);
1342 }
1343
1344 /**
1345 * @tc.name: OnUserChange
1346 * @tc.desc:
1347 * @tc.type: FUNC
1348 * @tc.require:
1349 */
1350 HWTEST_F(CloudDataTest, OnUserChange001, TestSize.Level0)
1351 {
1352 constexpr const uint32_t ACCOUNT_DEFAULT = 2;
1353 constexpr const uint32_t ACCOUNT_DELETE = 3;
1354 constexpr const uint32_t ACCOUNT_SWITCHED = 4;
1355 constexpr const uint32_t ACCOUNT_UNLOCKED = 5;
1356 auto ret = cloudServiceImpl_->OnUserChange(ACCOUNT_DEFAULT, "0", "test");
1357 EXPECT_EQ(ret, GeneralError::E_OK);
1358 ret = cloudServiceImpl_->OnUserChange(ACCOUNT_DELETE, "0", "test");
1359 EXPECT_EQ(ret, GeneralError::E_OK);
1360 ret = cloudServiceImpl_->OnUserChange(ACCOUNT_SWITCHED, "0", "test");
1361 EXPECT_EQ(ret, GeneralError::E_OK);
1362 ret = cloudServiceImpl_->OnUserChange(ACCOUNT_UNLOCKED, "0", "test");
1363 EXPECT_EQ(ret, GeneralError::E_OK);
1364 }
1365
1366 /**
1367 * @tc.name: DisableCloud
1368 * @tc.desc:
1369 * @tc.type: FUNC
1370 * @tc.require:
1371 */
1372 HWTEST_F(CloudDataTest, DisableCloud001, TestSize.Level0)
1373 {
1374 auto ret = cloudServiceImpl_->DisableCloud("test");
1375 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1376 ret = cloudServiceImpl_->DisableCloud(TEST_CLOUD_ID);
1377 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1378 }
1379
1380 /**
1381 * @tc.name: ChangeAppSwitch
1382 * @tc.desc:
1383 * @tc.type: FUNC
1384 * @tc.require:
1385 */
1386 HWTEST_F(CloudDataTest, ChangeAppSwitch, TestSize.Level0)
1387 {
1388 std::string id = "testId";
1389 std::string bundleName = "testName";
1390 auto ret = cloudServiceImpl_->ChangeAppSwitch(id, bundleName, CloudData::CloudService::SWITCH_ON);
1391 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1392 ret = cloudServiceImpl_->ChangeAppSwitch(TEST_CLOUD_ID, bundleName, CloudData::CloudService::SWITCH_ON);
1393 EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
1394 ret = cloudServiceImpl_->ChangeAppSwitch(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, CloudData::CloudService::SWITCH_OFF);
1395 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1396 }
1397
1398 /**
1399 * @tc.name: EnableCloud
1400 * @tc.desc:
1401 * @tc.type: FUNC
1402 * @tc.require:
1403 */
1404 HWTEST_F(CloudDataTest, EnableCloud, TestSize.Level0)
1405 {
1406 std::string bundleName = "testName";
1407 std::map<std::string, int32_t> switches;
1408 switches.insert_or_assign(TEST_CLOUD_BUNDLE, CloudData::CloudService::SWITCH_ON);
1409 switches.insert_or_assign(bundleName, CloudData::CloudService::SWITCH_ON);
1410 auto ret = cloudServiceImpl_->EnableCloud(TEST_CLOUD_ID, switches);
1411 EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
1412 }
1413
1414 /**
1415 * @tc.name: OnEnableCloud
1416 * @tc.desc:
1417 * @tc.type: FUNC
1418 * @tc.require:
1419 */
1420 HWTEST_F(CloudDataTest, OnEnableCloud, TestSize.Level1)
1421 {
1422 MessageParcel reply;
1423 MessageParcel data;
1424 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1425 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_ENABLE_CLOUD, data, reply);
1426 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1427 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1428 std::string id = "testId";
1429 std::map<std::string, int32_t> switches;
1430 ITypesUtil::Marshal(data, id, switches);
1431 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_ENABLE_CLOUD, data, reply);
1432 EXPECT_EQ(ret, ERR_NONE);
1433 }
1434
1435 /**
1436 * @tc.name: OnDisableCloud
1437 * @tc.desc:
1438 * @tc.type: FUNC
1439 * @tc.require:
1440 */
1441 HWTEST_F(CloudDataTest, OnDisableCloud, TestSize.Level1)
1442 {
1443 MessageParcel reply;
1444 MessageParcel data;
1445 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1446 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_DISABLE_CLOUD, data, reply);
1447 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1448 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1449 data.WriteString(TEST_CLOUD_ID);
1450 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_DISABLE_CLOUD, data, reply);
1451 EXPECT_EQ(ret, ERR_NONE);
1452 }
1453
1454 /**
1455 * @tc.name: OnChangeAppSwitch
1456 * @tc.desc:
1457 * @tc.type: FUNC
1458 * @tc.require:
1459 */
1460 HWTEST_F(CloudDataTest, OnChangeAppSwitch, TestSize.Level1)
1461 {
1462 MessageParcel reply;
1463 MessageParcel data;
1464 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1465 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_APP_SWITCH, data, reply);
1466 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1467 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1468 data.WriteString(TEST_CLOUD_ID);
1469 data.WriteString(TEST_CLOUD_BUNDLE);
1470 data.WriteInt32(CloudData::CloudService::SWITCH_ON);
1471 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_APP_SWITCH, data, reply);
1472 EXPECT_EQ(ret, ERR_NONE);
1473 }
1474
1475 /**
1476 * @tc.name: OnClean
1477 * @tc.desc:
1478 * @tc.type: FUNC
1479 * @tc.require:
1480 */
1481 HWTEST_F(CloudDataTest, OnClean, TestSize.Level1)
1482 {
1483 MessageParcel reply;
1484 MessageParcel data;
1485 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1486 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CLEAN, data, reply);
1487 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1488 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1489 std::string id = TEST_CLOUD_ID;
1490 std::map<std::string, int32_t> actions;
1491 ITypesUtil::Marshal(data, id, actions);
1492 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CLEAN, data, reply);
1493 EXPECT_EQ(ret, ERR_NONE);
1494 }
1495
1496 /**
1497 * @tc.name: OnNotifyDataChange
1498 * @tc.desc:
1499 * @tc.type: FUNC
1500 * @tc.require:
1501 */
1502 HWTEST_F(CloudDataTest, OnNotifyDataChange, TestSize.Level1)
1503 {
1504 MessageParcel reply;
1505 MessageParcel data;
1506 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1507 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_NOTIFY_DATA_CHANGE, data, reply);
1508 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1509 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1510 data.WriteString(TEST_CLOUD_ID);
1511 data.WriteString(TEST_CLOUD_BUNDLE);
1512 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_NOTIFY_DATA_CHANGE, data, reply);
1513 EXPECT_EQ(ret, ERR_NONE);
1514 }
1515
1516 /**
1517 * @tc.name: OnNotifyChange
1518 * @tc.desc:
1519 * @tc.type: FUNC
1520 * @tc.require:
1521 */
1522 HWTEST_F(CloudDataTest, OnNotifyChange, TestSize.Level1)
1523 {
1524 MessageParcel reply;
1525 MessageParcel data;
1526 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1527 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_NOTIFY_DATA_CHANGE_EXT, data, reply);
1528 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1529 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1530 data.WriteString(TEST_CLOUD_ID);
1531 data.WriteString(TEST_CLOUD_BUNDLE);
1532 int32_t userId = 100;
1533 data.WriteInt32(userId);
1534 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_NOTIFY_DATA_CHANGE_EXT, data, reply);
1535 EXPECT_EQ(ret, ERR_NONE);
1536 }
1537
1538 /**
1539 * @tc.name: OnQueryStatistics
1540 * @tc.desc:
1541 * @tc.type: FUNC
1542 * @tc.require:
1543 */
1544 HWTEST_F(CloudDataTest, OnQueryStatistics, TestSize.Level1)
1545 {
1546 MessageParcel reply;
1547 MessageParcel data;
1548 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1549 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_STATISTICS, data, reply);
1550 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1551 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1552 data.WriteString(TEST_CLOUD_ID);
1553 data.WriteString(TEST_CLOUD_BUNDLE);
1554 data.WriteString(TEST_CLOUD_STORE);
1555 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_STATISTICS, data, reply);
1556 EXPECT_EQ(ret, ERR_NONE);
1557 }
1558
1559 /**
1560 * @tc.name: OnQueryLastSyncInfo
1561 * @tc.desc:
1562 * @tc.type: FUNC
1563 * @tc.require:
1564 */
1565 HWTEST_F(CloudDataTest, OnQueryLastSyncInfo, TestSize.Level1)
1566 {
1567 MessageParcel reply;
1568 MessageParcel data;
1569 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1570 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_LAST_SYNC_INFO, data, reply);
1571 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1572 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1573 data.WriteString(TEST_CLOUD_ID);
1574 data.WriteString(TEST_CLOUD_BUNDLE);
1575 data.WriteString(TEST_CLOUD_STORE);
1576 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_LAST_SYNC_INFO, data, reply);
1577 EXPECT_EQ(ret, ERR_NONE);
1578 }
1579
1580 /**
1581 * @tc.name: OnSetGlobalCloudStrategy
1582 * @tc.desc:
1583 * @tc.type: FUNC
1584 * @tc.require:
1585 */
1586 HWTEST_F(CloudDataTest, OnSetGlobalCloudStrategy, TestSize.Level1)
1587 {
1588 MessageParcel reply;
1589 MessageParcel data;
1590 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1591 auto ret =
1592 cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SET_GLOBAL_CLOUD_STRATEGY, data, reply);
1593 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1594 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1595 uint32_t strategy = 0;
1596 std::vector<CommonType::Value> values;
1597 ITypesUtil::Marshal(data, strategy, values);
1598 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SET_GLOBAL_CLOUD_STRATEGY, data, reply);
1599 EXPECT_EQ(ret, ERR_NONE);
1600 }
1601
1602 /**
1603 * @tc.name: OnAllocResourceAndShare
1604 * @tc.desc:
1605 * @tc.type: FUNC
1606 * @tc.require:
1607 */
1608 HWTEST_F(CloudDataTest, OnAllocResourceAndShare, TestSize.Level1)
1609 {
1610 MessageParcel reply;
1611 MessageParcel data;
1612 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1613 auto ret = cloudServiceImpl_->OnRemoteRequest(
1614 CloudData::CloudService::TRANS_ALLOC_RESOURCE_AND_SHARE, data, reply);
1615 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1616 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1617 std::string storeId = "storeId";
1618 DistributedRdb::PredicatesMemo predicates;
1619 std::vector<std::string> columns;
1620 std::vector<CloudData::Participant> participants;
1621 ITypesUtil::Marshal(data, storeId, predicates, columns, participants);
1622 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_ALLOC_RESOURCE_AND_SHARE, data, reply);
1623 EXPECT_EQ(ret, ERR_NONE);
1624 }
1625
1626 /**
1627 * @tc.name: OnShare
1628 * @tc.desc:
1629 * @tc.type: FUNC
1630 * @tc.require:
1631 */
1632 HWTEST_F(CloudDataTest, OnShare, TestSize.Level1)
1633 {
1634 MessageParcel reply;
1635 MessageParcel data;
1636 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1637 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SHARE, data, reply);
1638 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1639 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1640 std::string sharingRes;
1641 CloudData::Participants participants;
1642 CloudData::Results results;
1643 ITypesUtil::Marshal(data, sharingRes, participants, results);
1644 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SHARE, data, reply);
1645 EXPECT_EQ(ret, ERR_NONE);
1646 }
1647
1648 /**
1649 * @tc.name: OnUnshare
1650 * @tc.desc:
1651 * @tc.type: FUNC
1652 * @tc.require:
1653 */
1654 HWTEST_F(CloudDataTest, OnUnshare, TestSize.Level1)
1655 {
1656 MessageParcel reply;
1657 MessageParcel data;
1658 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1659 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_UNSHARE, data, reply);
1660 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1661 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1662 std::string sharingRes;
1663 CloudData::Participants participants;
1664 CloudData::Results results;
1665 ITypesUtil::Marshal(data, sharingRes, participants, results);
1666 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_UNSHARE, data, reply);
1667 EXPECT_EQ(ret, ERR_NONE);
1668 }
1669
1670 /**
1671 * @tc.name: OnExit
1672 * @tc.desc:
1673 * @tc.type: FUNC
1674 * @tc.require:
1675 */
1676 HWTEST_F(CloudDataTest, OnExit, TestSize.Level1)
1677 {
1678 MessageParcel reply;
1679 MessageParcel data;
1680 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1681 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_EXIT, data, reply);
1682 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1683 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1684 std::string sharingRes;
1685 std::pair<int32_t, std::string> result;
1686 ITypesUtil::Marshal(data, sharingRes, result);
1687 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_EXIT, data, reply);
1688 EXPECT_EQ(ret, ERR_NONE);
1689 }
1690
1691 /**
1692 * @tc.name: OnChangePrivilege
1693 * @tc.desc:
1694 * @tc.type: FUNC
1695 * @tc.require:
1696 */
1697 HWTEST_F(CloudDataTest, OnChangePrivilege, TestSize.Level1)
1698 {
1699 MessageParcel reply;
1700 MessageParcel data;
1701 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1702 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_PRIVILEGE, data, reply);
1703 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1704 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1705 std::string sharingRes;
1706 CloudData::Participants participants;
1707 CloudData::Results results;
1708 ITypesUtil::Marshal(data, sharingRes, participants, results);
1709 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_PRIVILEGE, data, reply);
1710 EXPECT_EQ(ret, ERR_NONE);
1711 }
1712
1713 /**
1714 * @tc.name: OnQuery
1715 * @tc.desc:
1716 * @tc.type: FUNC
1717 * @tc.require:
1718 */
1719 HWTEST_F(CloudDataTest, OnQuery, TestSize.Level1)
1720 {
1721 MessageParcel reply;
1722 MessageParcel data;
1723 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1724 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY, data, reply);
1725 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1726 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1727 std::string sharingRes;
1728 CloudData::QueryResults results;
1729 ITypesUtil::Marshal(data, sharingRes, results);
1730 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY, data, reply);
1731 EXPECT_EQ(ret, ERR_NONE);
1732 }
1733
1734 /**
1735 * @tc.name: OnQueryByInvitation
1736 * @tc.desc:
1737 * @tc.type: FUNC
1738 * @tc.require:
1739 */
1740 HWTEST_F(CloudDataTest, OnQueryByInvitation, TestSize.Level1)
1741 {
1742 MessageParcel reply;
1743 MessageParcel data;
1744 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1745 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_BY_INVITATION, data, reply);
1746 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1747 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1748 std::string invitation;
1749 CloudData::QueryResults results;
1750 ITypesUtil::Marshal(data, invitation, results);
1751 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_BY_INVITATION, data, reply);
1752 EXPECT_EQ(ret, ERR_NONE);
1753 }
1754
1755 /**
1756 * @tc.name: OnConfirmInvitation
1757 * @tc.desc:
1758 * @tc.type: FUNC
1759 * @tc.require:
1760 */
1761 HWTEST_F(CloudDataTest, OnConfirmInvitation, TestSize.Level1)
1762 {
1763 MessageParcel reply;
1764 MessageParcel data;
1765 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1766 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CONFIRM_INVITATION, data, reply);
1767 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1768 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1769 std::string invitation;
1770 int32_t confirmation = 0;
1771 std::tuple<int32_t, std::string, std::string> result;
1772 ITypesUtil::Marshal(data, invitation, confirmation, result);
1773 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CONFIRM_INVITATION, data, reply);
1774 EXPECT_EQ(ret, ERR_NONE);
1775 }
1776
1777 /**
1778 * @tc.name: OnChangeConfirmation
1779 * @tc.desc:
1780 * @tc.type: FUNC
1781 * @tc.require:
1782 */
1783 HWTEST_F(CloudDataTest, OnChangeConfirmation, TestSize.Level1)
1784 {
1785 MessageParcel reply;
1786 MessageParcel data;
1787 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1788 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_CONFIRMATION, data, reply);
1789 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1790 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1791 std::string sharingRes;
1792 int32_t confirmation = 0;
1793 std::pair<int32_t, std::string> result;
1794 ITypesUtil::Marshal(data, sharingRes, confirmation, result);
1795 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_CONFIRMATION, data, reply);
1796 EXPECT_EQ(ret, ERR_NONE);
1797 }
1798
1799 /**
1800 * @tc.name: OnSetCloudStrategy
1801 * @tc.desc:
1802 * @tc.type: FUNC
1803 * @tc.require:
1804 */
1805 HWTEST_F(CloudDataTest, OnSetCloudStrategy, TestSize.Level0)
1806 {
1807 MessageParcel reply;
1808 MessageParcel data;
1809 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1810 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SET_CLOUD_STRATEGY, data, reply);
1811 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1812 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1813 uint32_t strategy = 0;
1814 std::vector<CommonType::Value> values;
1815 ITypesUtil::Marshal(data, strategy, values);
1816 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SET_CLOUD_STRATEGY, data, reply);
1817 EXPECT_EQ(ret, ERR_NONE);
1818 }
1819
1820 /**
1821 * @tc.name: OnCloudSync
1822 * @tc.desc:
1823 * @tc.type: FUNC
1824 * @tc.require:
1825 */
1826 HWTEST_F(CloudDataTest, OnCloudSync, TestSize.Level0)
1827 {
1828 MessageParcel reply;
1829 MessageParcel data;
1830 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1831 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CLOUD_SYNC, data, reply);
1832 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1833 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1834 std::string bundleName = "bundleName";
1835 std::string storeId = "storeId";
1836 CloudData::CloudService::Option option;
1837 option.syncMode = 4;
1838 option.seqNum = 1;
1839 ITypesUtil::Marshal(data, bundleName, storeId, option);
1840 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CLOUD_SYNC, data, reply);
1841 EXPECT_EQ(ret, ERR_NONE);
1842 }
1843
1844 /**
1845 * @tc.name: OnInitNotifier
1846 * @tc.desc:
1847 * @tc.type: FUNC
1848 * @tc.require:
1849 */
1850 HWTEST_F(CloudDataTest, OnInitNotifier, TestSize.Level0)
1851 {
1852 MessageParcel reply;
1853 MessageParcel data;
1854 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1855 auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_INIT_NOTIFIER, data, reply);
1856 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1857 data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1858 std::string bundleName = "bundleName";
1859 sptr<IRemoteObject> notifier = nullptr;
1860 ITypesUtil::Marshal(data, bundleName, notifier);
1861 ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_INIT_NOTIFIER, data, reply);
1862 EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1863 }
1864
1865 /**
1866 * @tc.name: SharingUtil001
1867 * @tc.desc:
1868 * @tc.type: FUNC
1869 * @tc.require:
1870 */
1871 HWTEST_F(CloudDataTest, SharingUtil001, TestSize.Level0)
1872 {
1873 auto cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_UNKNOWN);
1874 EXPECT_EQ(cfm, SharingCfm::CFM_UNKNOWN);
1875 cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_ACCEPTED);
1876 EXPECT_EQ(cfm, SharingCfm::CFM_ACCEPTED);
1877 cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_REJECTED);
1878 EXPECT_EQ(cfm, SharingCfm::CFM_REJECTED);
1879 cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_SUSPENDED);
1880 EXPECT_EQ(cfm, SharingCfm::CFM_SUSPENDED);
1881 cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_UNAVAILABLE);
1882 EXPECT_EQ(cfm, SharingCfm::CFM_UNAVAILABLE);
1883 cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_BUTT);
1884 EXPECT_EQ(cfm, SharingCfm::CFM_UNKNOWN);
1885 }
1886
1887 /**
1888 * @tc.name: SharingUtil002
1889 * @tc.desc:
1890 * @tc.type: FUNC
1891 * @tc.require:
1892 */
1893 HWTEST_F(CloudDataTest, SharingUtil002, TestSize.Level0)
1894 {
1895 auto cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_UNKNOWN);
1896 EXPECT_EQ(cfm, Confirmation::CFM_UNKNOWN);
1897 cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_ACCEPTED);
1898 EXPECT_EQ(cfm, Confirmation::CFM_ACCEPTED);
1899 cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_REJECTED);
1900 EXPECT_EQ(cfm, Confirmation::CFM_REJECTED);
1901 cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_SUSPENDED);
1902 EXPECT_EQ(cfm, Confirmation::CFM_SUSPENDED);
1903 cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_UNAVAILABLE);
1904 EXPECT_EQ(cfm, Confirmation::CFM_UNAVAILABLE);
1905 cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_BUTT);
1906 EXPECT_EQ(cfm, Confirmation::CFM_UNKNOWN);
1907 }
1908
1909 /**
1910 * @tc.name: SharingUtil003
1911 * @tc.desc:
1912 * @tc.type: FUNC
1913 * @tc.require:
1914 */
1915 HWTEST_F(CloudDataTest, SharingUtil003, TestSize.Level0)
1916 {
1917 auto status = CloudData::SharingUtil::Convert(CenterCode::IPC_ERROR);
1918 EXPECT_EQ(status, Status::IPC_ERROR);
1919 status = CloudData::SharingUtil::Convert(CenterCode::NOT_SUPPORT);
1920 EXPECT_EQ(status, Status::SUCCESS);
1921 }
1922
1923 /**
1924 * @tc.name: SharingUtil004
1925 * @tc.desc:
1926 * @tc.type: FUNC
1927 * @tc.require:
1928 */
1929 HWTEST_F(CloudDataTest, SharingUtil004, TestSize.Level0)
1930 {
1931 auto status = CloudData::SharingUtil::Convert(GenErr::E_OK);
1932 EXPECT_EQ(status, Status::SUCCESS);
1933 status = CloudData::SharingUtil::Convert(GenErr::E_ERROR);
1934 EXPECT_EQ(status, Status::ERROR);
1935 status = CloudData::SharingUtil::Convert(GenErr::E_INVALID_ARGS);
1936 EXPECT_EQ(status, Status::INVALID_ARGUMENT);
1937 status = CloudData::SharingUtil::Convert(GenErr::E_BLOCKED_BY_NETWORK_STRATEGY);
1938 EXPECT_EQ(status, Status::STRATEGY_BLOCKING);
1939 status = CloudData::SharingUtil::Convert(GenErr::E_CLOUD_DISABLED);
1940 EXPECT_EQ(status, Status::CLOUD_DISABLE);
1941 status = CloudData::SharingUtil::Convert(GenErr::E_NETWORK_ERROR);
1942 EXPECT_EQ(status, Status::NETWORK_ERROR);
1943 status = CloudData::SharingUtil::Convert(GenErr::E_BUSY);
1944 EXPECT_EQ(status, Status::ERROR);
1945 }
1946
1947 /**
1948 * @tc.name: DoCloudSync
1949 * @tc.desc: Test the executor_ uninitialized and initialized scenarios
1950 * @tc.type: FUNC
1951 * @tc.require:
1952 */
1953 HWTEST_F(CloudDataTest, DoCloudSync, TestSize.Level0)
1954 {
1955 int32_t user = 100;
1956 CloudData::SyncManager sync;
1957 CloudData::SyncManager::SyncInfo info(user);
1958 auto ret = sync.DoCloudSync(info);
1959 EXPECT_EQ(ret, GenErr::E_NOT_INIT);
1960 ret = sync.StopCloudSync(user);
1961 EXPECT_EQ(ret, GenErr::E_NOT_INIT);
1962 size_t max = 12;
1963 size_t min = 5;
1964 sync.executor_ = std::make_shared<ExecutorPool>(max, min);
1965 ret = sync.DoCloudSync(info);
1966 EXPECT_EQ(ret, GenErr::E_OK);
1967 int32_t invalidUser = -1;
1968 sync.StopCloudSync(invalidUser);
1969 ret = sync.StopCloudSync(user);
1970 EXPECT_EQ(ret, GenErr::E_OK);
1971 }
1972
1973 /**
1974 * @tc.name: GetPostEventTask
1975 * @tc.desc: Test the interface to verify the package name and table name
1976 * @tc.type: FUNC
1977 * @tc.require:
1978 */
1979 HWTEST_F(CloudDataTest, GetPostEventTask, TestSize.Level0)
1980 {
1981 std::vector<SchemaMeta> schemas;
1982 schemaMeta_.databases[0].name = "test";
1983 schemas.push_back(schemaMeta_);
1984 schemaMeta_.bundleName = "test";
1985 schemas.push_back(schemaMeta_);
1986
1987 int32_t user = 100;
1988 CloudData::SyncManager::SyncInfo info(user);
1989 std::vector<std::string> value;
1990 info.tables_.insert_or_assign(TEST_CLOUD_STORE, value);
1991
1992 CloudData::SyncManager sync;
1993 std::map<std::string, std::string> traceIds;
1994 auto task = sync.GetPostEventTask(schemas, cloudInfo_, info, true, traceIds);
1995 task();
1996 std::vector<CloudLastSyncInfo> lastSyncInfos;
1997 MetaDataManager::GetInstance().LoadMeta(CloudLastSyncInfo::GetKey(user, "test", "test"), lastSyncInfos, true);
1998 EXPECT_TRUE(lastSyncInfos.size() == 0);
1999 }
2000
2001 /**
2002 * @tc.name: GetRetryer001
2003 * @tc.desc: Test the input parameters of different interfaces
2004 * @tc.type: FUNC
2005 * @tc.require:
2006 */
2007 HWTEST_F(CloudDataTest, GetRetryer001, TestSize.Level0)
2008 {
2009 int32_t user = 100;
2010 CloudData::SyncManager::SyncInfo info(user);
2011 CloudData::SyncManager sync;
2012 CloudData::SyncManager::Duration duration;
2013 std::string prepareTraceId;
2014 auto ret = sync.GetRetryer(CloudData::SyncManager::RETRY_TIMES, info, user)(duration, E_OK, E_OK, prepareTraceId);
2015 EXPECT_TRUE(ret);
2016 ret = sync.GetRetryer(CloudData::SyncManager::RETRY_TIMES, info, user)(
2017 duration, E_SYNC_TASK_MERGED, E_SYNC_TASK_MERGED, prepareTraceId);
2018 EXPECT_TRUE(ret);
2019 ret = sync.GetRetryer(0, info, user)(duration, E_OK, E_OK, prepareTraceId);
2020 EXPECT_TRUE(ret);
2021 ret = sync.GetRetryer(0, info, user)(duration, E_SYNC_TASK_MERGED, E_SYNC_TASK_MERGED, prepareTraceId);
2022 EXPECT_TRUE(ret);
2023 }
2024
2025 /**
2026 * @tc.name: GetRetryer002
2027 * @tc.desc: Test the executor_ is nullptr scenarios.
2028 * @tc.type: FUNC
2029 * @tc.require:
2030 */
2031 HWTEST_F(CloudDataTest, GetRetryer002, TestSize.Level0)
2032 {
2033 int32_t user = 100;
2034 std::string prepareTraceId;
2035 CloudData::SyncManager sync;
2036 sync.executor_ = nullptr;
2037 int32_t evtId = 100;
2038 auto event = std::make_unique<CloudData::SyncManager::Event>(evtId);
2039 auto handler = sync.GetClientChangeHandler();
2040 handler(*event);
2041 CloudData::SyncManager::Duration duration;
2042 CloudData::SyncManager::SyncInfo info(user);
2043 auto ret = sync.GetRetryer(0, info, user)(duration, E_CLOUD_DISABLED, E_CLOUD_DISABLED, prepareTraceId);
2044 EXPECT_FALSE(ret);
2045 }
2046
2047 /**
2048 * @tc.name: GetCallback
2049 * @tc.desc: Test the processing logic of different progress callbacks
2050 * @tc.type: FUNC
2051 * @tc.require:
2052 */
2053 HWTEST_F(CloudDataTest, GetCallback, TestSize.Level0)
2054 {
2055 int32_t user = 100;
2056 CloudData::SyncManager::SyncInfo info(user);
2057 CloudData::SyncManager sync;
2058 DistributedData::GenDetails result;
2059 StoreInfo storeInfo;
2060 storeInfo.user = user;
2061 storeInfo.bundleName = "testBundleName";
2062 int32_t triggerMode = MODE_DEFAULT;
2063 std::string prepareTraceId;
2064 GenAsync async = nullptr;
2065 sync.GetCallback(async, storeInfo, triggerMode, prepareTraceId, user)(result);
2066 int32_t process = 0;
__anonb11b2c810602(const GenDetails &details) 2067 async = [&process](const GenDetails &details) {
2068 process = details.begin()->second.progress;
2069 };
2070 GenProgressDetail detail;
2071 detail.progress = GenProgress::SYNC_IN_PROGRESS;
2072 result.insert_or_assign("test", detail);
2073 sync.GetCallback(async, storeInfo, triggerMode, prepareTraceId, user)(result);
2074 EXPECT_EQ(process, GenProgress::SYNC_IN_PROGRESS);
2075 detail.progress = GenProgress::SYNC_FINISH;
2076 result.insert_or_assign("test", detail);
2077 storeInfo.user = -1;
2078 sync.GetCallback(async, storeInfo, triggerMode, prepareTraceId, user)(result);
2079 storeInfo.user = user;
2080 sync.GetCallback(async, storeInfo, triggerMode, prepareTraceId, user)(result);
2081 EXPECT_EQ(process, GenProgress::SYNC_FINISH);
2082 }
2083
2084 /**
2085 * @tc.name: GetInterval
2086 * @tc.desc: Test the Interval transformation logic of the interface
2087 * @tc.type: FUNC
2088 * @tc.require:
2089 */
2090 HWTEST_F(CloudDataTest, GetInterval, TestSize.Level0)
2091 {
2092 CloudData::SyncManager sync;
2093
2094 auto ret = sync.GetInterval(E_LOCKED_BY_OTHERS);
2095 EXPECT_EQ(ret, CloudData::SyncManager::LOCKED_INTERVAL);
2096 ret = sync.GetInterval(E_BUSY);
2097 EXPECT_EQ(ret, CloudData::SyncManager::BUSY_INTERVAL);
2098 ret = sync.GetInterval(E_OK);
2099 EXPECT_EQ(ret, CloudData::SyncManager::RETRY_INTERVAL);
2100 }
2101
2102 /**
2103 * @tc.name: GetCloudSyncInfo
2104 * @tc.desc: Test get cloudInfo
2105 * @tc.type: FUNC
2106 * @tc.require:
2107 */
2108 HWTEST_F(CloudDataTest, GetCloudSyncInfo, TestSize.Level0)
2109 {
2110 CloudData::SyncManager sync;
2111 CloudInfo cloud;
2112 cloud.user = cloudInfo_.user;
2113 cloud.enableCloud = false;
2114 CloudData::SyncManager::SyncInfo info(cloudInfo_.user);
2115 MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
2116 info.bundleName_ = TEST_CLOUD_BUNDLE;
2117 auto ret = sync.GetCloudSyncInfo(info, cloud);
2118 EXPECT_TRUE(!ret.empty());
2119 }
2120
2121 /**
2122 * @tc.name: RetryCallback
2123 * @tc.desc: Test the retry logic
2124 * @tc.type: FUNC
2125 * @tc.require:
2126 */
2127 HWTEST_F(CloudDataTest, RetryCallback, TestSize.Level0)
2128 {
2129 int32_t user = 100;
2130 std::string prepareTraceId;
2131 CloudData::SyncManager sync;
2132 StoreInfo storeInfo;
2133 int32_t retCode = -1;
2134 CloudData::SyncManager::Retryer retry = [&retCode](CloudData::SyncManager::Duration interval, int32_t code,
__anonb11b2c810702(CloudData::SyncManager::Duration interval, int32_t code, int32_t dbCode, const std::string &prepareTraceId) 2135 int32_t dbCode, const std::string &prepareTraceId) {
2136 retCode = code;
2137 return true;
2138 };
2139 DistributedData::GenDetails result;
2140 auto task = sync.RetryCallback(storeInfo, retry, MODE_DEFAULT, prepareTraceId, user);
2141 task(result);
2142 GenProgressDetail detail;
2143 detail.progress = GenProgress::SYNC_IN_PROGRESS;
2144 detail.code = 100;
2145 result.insert_or_assign("test", detail);
2146 task = sync.RetryCallback(storeInfo, retry, MODE_DEFAULT, prepareTraceId, user);
2147 task(result);
2148 EXPECT_EQ(retCode, detail.code);
2149 }
2150
2151 /**
2152 * @tc.name: UpdateCloudInfoFromServer
2153 * @tc.desc: Test updating cloudinfo from the server
2154 * @tc.type: FUNC
2155 * @tc.require:
2156 */
2157 HWTEST_F(CloudDataTest, UpdateCloudInfoFromServer, TestSize.Level0)
2158 {
2159 auto ret = cloudServiceImpl_->UpdateCloudInfoFromServer(cloudInfo_.user);
2160 EXPECT_EQ(ret, E_OK);
2161 }
2162
2163 /**
2164 * @tc.name: GetCloudInfo
2165 * @tc.desc: Test get cloudInfo
2166 * @tc.type: FUNC
2167 * @tc.require:
2168 */
2169 HWTEST_F(CloudDataTest, GetCloudInfo, TestSize.Level1)
2170 {
2171 MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
2172 auto ret = cloudServiceImpl_->GetCloudInfo(cloudInfo_.user);
2173 EXPECT_EQ(ret.first, CloudData::SUCCESS);
2174 }
2175
2176 /**
2177 * @tc.name: UpdateSchemaFromServer_001
2178 * @tc.desc: Test get UpdateSchemaFromServer
2179 * @tc.type: FUNC
2180 * @tc.require:
2181 */
2182 HWTEST_F(CloudDataTest, UpdateSchemaFromServer_001, TestSize.Level1)
2183 {
2184 auto status = cloudServiceImpl_->UpdateSchemaFromServer(cloudInfo_.user);
2185 EXPECT_EQ(status, CloudData::SUCCESS);
2186 }
2187
2188 /**
2189 * @tc.name: OnAppInstallTest
2190 * @tc.desc: Test the OnAppInstallTest
2191 * @tc.type: FUNC
2192 * @tc.require:
2193 */
2194 HWTEST_F(CloudDataTest, OnAppInstallTest, TestSize.Level1)
2195 {
2196 ZLOGI("CloudDataTest OnAppInstallTest start");
2197 ASSERT_NE(cloudServiceImpl_, nullptr);
2198 ASSERT_NE(cloudServiceImpl_->factory_.staticActs_, nullptr);
2199 int32_t index = 0;
2200 auto status = cloudServiceImpl_->factory_.staticActs_->OnAppInstall(TEST_CLOUD_BUNDLE, cloudInfo_.user, index);
2201 EXPECT_EQ(status, GeneralError::E_OK);
2202 }
2203
2204 /**
2205 * @tc.name: OnAppUpdateTest
2206 * @tc.desc: Test the OnAppUpdateTest
2207 * @tc.type: FUNC
2208 * @tc.require:
2209 */
2210 HWTEST_F(CloudDataTest, OnAppUpdateTest, TestSize.Level1)
2211 {
2212 ZLOGI("CloudDataTest OnAppUpdateTest start");
2213 ASSERT_NE(cloudServiceImpl_, nullptr);
2214 ASSERT_NE(cloudServiceImpl_->factory_.staticActs_, nullptr);
2215 int32_t index = 0;
2216 auto status = cloudServiceImpl_->factory_.staticActs_->OnAppUpdate(TEST_CLOUD_BUNDLE, cloudInfo_.user, index);
2217 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
2218 }
2219
2220 /**
2221 * @tc.name: UpdateE2eeEnableTest
2222 * @tc.desc: Test the UpdateE2eeEnable
2223 * @tc.type: FUNC
2224 * @tc.require:
2225 */
2226 HWTEST_F(CloudDataTest, UpdateE2eeEnableTest, TestSize.Level1)
2227 {
2228 SchemaMeta schemaMeta;
2229 std::string schemaKey = CloudInfo::GetSchemaKey(cloudInfo_.user, TEST_CLOUD_BUNDLE, 0);
2230 ASSERT_TRUE(MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true));
2231 EXPECT_EQ(schemaMeta.e2eeEnable, schemaMeta_.e2eeEnable);
2232
2233 ASSERT_NE(cloudServiceImpl_, nullptr);
2234 cloudServiceImpl_->UpdateE2eeEnable(schemaKey, false, TEST_CLOUD_BUNDLE);
2235 ASSERT_TRUE(MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true));
2236 EXPECT_EQ(schemaMeta.e2eeEnable, schemaMeta_.e2eeEnable);
2237 cloudServiceImpl_->UpdateE2eeEnable(schemaKey, true, TEST_CLOUD_BUNDLE);
2238 ASSERT_TRUE(MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true));
2239 EXPECT_EQ(schemaMeta.e2eeEnable, true);
2240 }
2241
2242 /**
2243 * @tc.name: SubTask
2244 * @tc.desc: Test the subtask execution logic
2245 * @tc.type: FUNC
2246 * @tc.require:
2247 */
2248 HWTEST_F(CloudDataTest, SubTask, TestSize.Level0)
2249 {
2250 DistributedData::Subscription sub;
2251 cloudServiceImpl_->InitSubTask(sub, 0);
2252 MetaDataManager::GetInstance().LoadMeta(Subscription::GetKey(cloudInfo_.user), sub, true);
2253 cloudServiceImpl_->InitSubTask(sub, 0);
2254 int32_t userId = 0;
__anonb11b2c810802() 2255 CloudData::CloudServiceImpl::Task task = [&userId]() {
2256 userId = cloudInfo_.user;
2257 };
2258 cloudServiceImpl_->GenSubTask(task, cloudInfo_.user)();
2259 EXPECT_EQ(userId, cloudInfo_.user);
2260 }
2261
2262 /**
2263 * @tc.name: ConvertCursor
2264 * @tc.desc: Test the cursor conversion logic when the ResultSet is empty and non-null
2265 * @tc.type: FUNC
2266 * @tc.require:
2267 */
2268 HWTEST_F(CloudDataTest, ConvertCursor, TestSize.Level0)
2269 {
2270 std::map<std::string, DistributedData::Value> entry;
2271 entry.insert_or_assign("test", "entry");
2272 auto resultSet = std::make_shared<CursorMock::ResultSet>(1, entry);
2273 auto cursor = std::make_shared<CursorMock>(resultSet);
2274 auto result = cloudServiceImpl_->ConvertCursor(cursor);
2275 EXPECT_TRUE(!result.empty());
2276 auto resultSet1 = std::make_shared<CursorMock::ResultSet>();
2277 auto cursor1 = std::make_shared<CursorMock>(resultSet1);
2278 auto result1 = cloudServiceImpl_->ConvertCursor(cursor1);
2279 EXPECT_TRUE(result1.empty());
2280 }
2281
2282 /**
2283 * @tc.name: GetDbInfoFromExtraData
2284 * @tc.desc: Test the GetDbInfoFromExtraData function input parameters of different parameters
2285 * @tc.type: FUNC
2286 * @tc.require:
2287 */
2288 HWTEST_F(CloudDataTest, GetDbInfoFromExtraData, TestSize.Level0)
2289 {
2290 SchemaMeta::Database database;
2291 database.name = TEST_CLOUD_STORE;
2292 database.alias = TEST_CLOUD_DATABASE_ALIAS_1;
2293
2294 SchemaMeta schemaMeta;
2295 schemaMeta.databases.push_back(database);
2296
2297 SchemaMeta::Table table;
2298 table.name = "test_cloud_table_name";
2299 table.alias = "test_cloud_table_alias";
2300 database.tables.push_back(table);
2301 SchemaMeta::Table table1;
2302 table1.name = "test_cloud_table_name1";
2303 table1.alias = "test_cloud_table_alias1";
2304 table1.sharedTableName = "test_share_table_name1";
2305 database.tables.emplace_back(table1);
2306
2307 database.alias = TEST_CLOUD_DATABASE_ALIAS_2;
2308 schemaMeta.databases.push_back(database);
2309
2310 ExtraData extraData;
2311 extraData.info.containerName = TEST_CLOUD_DATABASE_ALIAS_2;
2312 auto result = cloudServiceImpl_->GetDbInfoFromExtraData(extraData, schemaMeta);
2313 EXPECT_EQ(result.begin()->first, TEST_CLOUD_STORE);
2314
2315 std::string tableName = "test_cloud_table_alias2";
2316 extraData.info.tables.emplace_back(tableName);
2317 result = cloudServiceImpl_->GetDbInfoFromExtraData(extraData, schemaMeta);
2318 EXPECT_EQ(result.begin()->first, TEST_CLOUD_STORE);
2319
2320 std::string tableName1 = "test_cloud_table_alias1";
2321 extraData.info.tables.emplace_back(tableName1);
2322 extraData.info.scopes.emplace_back(DistributedData::ExtraData::SHARED_TABLE);
2323 result = cloudServiceImpl_->GetDbInfoFromExtraData(extraData, schemaMeta);
2324 EXPECT_EQ(result.begin()->first, TEST_CLOUD_STORE);
2325 }
2326
2327 /**
2328 * @tc.name: QueryTableStatistic
2329 * @tc.desc: Test the QueryTableStatistic function input parameters of different parameters
2330 * @tc.type: FUNC
2331 * @tc.require:
2332 */
2333 HWTEST_F(CloudDataTest, QueryTableStatistic, TestSize.Level0)
2334 {
2335 auto store = std::make_shared<GeneralStoreMock>();
2336 if (store != nullptr) {
2337 std::map<std::string, Value> entry = { { "inserted", "TEST" }, { "updated", "TEST" }, { "normal", "TEST" } };
2338 store->MakeCursor(entry);
2339 }
2340 auto [ret, result] = cloudServiceImpl_->QueryTableStatistic("test", store);
2341 EXPECT_TRUE(ret);
2342 if (store != nullptr) {
2343 std::map<std::string, Value> entry = { { "Test", 1 } };
2344 store->MakeCursor(entry);
2345 }
2346 std::tie(ret, result) = cloudServiceImpl_->QueryTableStatistic("test", store);
2347 EXPECT_TRUE(ret);
2348
2349 if (store != nullptr) {
2350 store->cursor_ = nullptr;
2351 }
2352 std::tie(ret, result) = cloudServiceImpl_->QueryTableStatistic("test", store);
2353 EXPECT_FALSE(ret);
2354 }
2355
2356 /**
2357 * @tc.name: GetSchemaMeta
2358 * @tc.desc: Test the GetSchemaMeta function input parameters of different parameters
2359 * @tc.type: FUNC
2360 * @tc.require:
2361 */
2362 HWTEST_F(CloudDataTest, GetSchemaMeta, TestSize.Level0)
2363 {
2364 int32_t userId = 101;
2365 int32_t instanceId = 0;
2366 CloudInfo cloudInfo;
2367 cloudInfo.user = userId;
2368 cloudInfo.id = TEST_CLOUD_ID;
2369 cloudInfo.enableCloud = true;
2370
2371 CloudInfo::AppInfo appInfo;
2372 appInfo.bundleName = TEST_CLOUD_BUNDLE;
2373 appInfo.appId = TEST_CLOUD_APPID;
2374 appInfo.version = 1;
2375 appInfo.cloudSwitch = true;
2376
2377 cloudInfo.apps[TEST_CLOUD_BUNDLE] = std::move(appInfo);
2378 MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true);
2379 std::string bundleName = "testName";
2380 auto [status, meta] = cloudServiceImpl_->GetSchemaMeta(userId, bundleName, instanceId);
2381 EXPECT_EQ(status, CloudData::CloudService::ERROR);
2382 bundleName = TEST_CLOUD_BUNDLE;
2383 DistributedData::SchemaMeta schemeMeta;
2384 schemeMeta.bundleName = TEST_CLOUD_BUNDLE;
2385 schemeMeta.metaVersion = DistributedData::SchemaMeta::CURRENT_VERSION + 1;
2386 MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE, instanceId), schemeMeta, true);
2387 std::tie(status, meta) = cloudServiceImpl_->GetSchemaMeta(userId, bundleName, instanceId);
2388 EXPECT_EQ(status, CloudData::CloudService::ERROR);
2389 schemeMeta.metaVersion = DistributedData::SchemaMeta::CURRENT_VERSION;
2390 MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE, instanceId), schemeMeta, true);
2391 std::tie(status, meta) = cloudServiceImpl_->GetSchemaMeta(userId, bundleName, instanceId);
2392 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
2393 EXPECT_EQ(meta.metaVersion, DistributedData::SchemaMeta::CURRENT_VERSION);
2394 MetaDataManager::GetInstance().DelMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE, instanceId), true);
2395 MetaDataManager::GetInstance().DelMeta(cloudInfo.GetKey(), true);
2396 }
2397
2398 /**
2399 * @tc.name: GetAppSchemaFromServer
2400 * @tc.desc: Test the GetAppSchemaFromServer function input parameters of different parameters
2401 * @tc.type: FUNC
2402 * @tc.require:
2403 */
2404 HWTEST_F(CloudDataTest, GetAppSchemaFromServer, TestSize.Level0)
2405 {
2406 int32_t userId = CloudServerMock::INVALID_USER_ID;
2407 std::string bundleName;
2408 delegate_.isNetworkAvailable_ = false;
2409 auto [status, meta] = cloudServiceImpl_->GetAppSchemaFromServer(userId, bundleName);
2410 EXPECT_EQ(status, CloudData::CloudService::NETWORK_ERROR);
2411 delegate_.isNetworkAvailable_ = true;
2412 std::tie(status, meta) = cloudServiceImpl_->GetAppSchemaFromServer(userId, bundleName);
2413 EXPECT_EQ(status, CloudData::CloudService::SCHEMA_INVALID);
2414 userId = 100;
2415 std::tie(status, meta) = cloudServiceImpl_->GetAppSchemaFromServer(userId, bundleName);
2416 EXPECT_EQ(status, CloudData::CloudService::SCHEMA_INVALID);
2417 bundleName = TEST_CLOUD_BUNDLE;
2418 std::tie(status, meta) = cloudServiceImpl_->GetAppSchemaFromServer(userId, bundleName);
2419 EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
2420 EXPECT_EQ(meta.bundleName, schemaMeta_.bundleName);
2421 }
2422
2423 /**
2424 * @tc.name: OnAppUninstall
2425 * @tc.desc: Test the OnAppUninstall function delete the subscription data
2426 * @tc.type: FUNC
2427 * @tc.require:
2428 */
2429 HWTEST_F(CloudDataTest, OnAppUninstall, TestSize.Level0)
2430 {
2431 CloudData::CloudServiceImpl::CloudStatic cloudStatic;
2432 int32_t userId = 1001;
2433 Subscription sub;
2434 sub.expiresTime.insert_or_assign(TEST_CLOUD_BUNDLE, 0);
2435 MetaDataManager::GetInstance().SaveMeta(Subscription::GetKey(userId), sub, true);
2436 CloudInfo cloudInfo;
2437 cloudInfo.user = userId;
2438 CloudInfo::AppInfo appInfo;
2439 cloudInfo.apps.insert_or_assign(TEST_CLOUD_BUNDLE, appInfo);
2440 MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true);
2441 int32_t index = 1;
2442 auto ret = cloudStatic.OnAppUninstall(TEST_CLOUD_BUNDLE, userId, index);
2443 EXPECT_EQ(ret, E_OK);
2444 Subscription sub1;
2445 EXPECT_TRUE(MetaDataManager::GetInstance().LoadMeta(Subscription::GetKey(userId), sub1, true));
2446 EXPECT_EQ(sub1.expiresTime.size(), 0);
2447 }
2448
2449 /**
2450 * @tc.name: GetCloudInfo
2451 * @tc.desc: Test the GetCloudInfo with invalid parameters
2452 * @tc.type: FUNC
2453 * @tc.require:
2454 */
2455 HWTEST_F(CloudDataTest, GetCloudInfo001, TestSize.Level1)
2456 {
2457 int32_t userId = 1000;
2458 auto [status, cloudInfo] = cloudServiceImpl_->GetCloudInfo(userId);
2459 EXPECT_EQ(status, CloudData::CloudService::ERROR);
2460 MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
2461 delegate_.isNetworkAvailable_ = false;
2462 std::tie(status, cloudInfo) = cloudServiceImpl_->GetCloudInfo(cloudInfo_.user);
2463 EXPECT_EQ(status, CloudData::CloudService::NETWORK_ERROR);
2464 delegate_.isNetworkAvailable_ = true;
2465 }
2466
2467 /**
2468 * @tc.name: PreShare
2469 * @tc.desc: Test the PreShare with invalid parameters
2470 * @tc.type: FUNC
2471 * @tc.require:
2472 */
2473 HWTEST_F(CloudDataTest, PreShare, TestSize.Level0)
2474 {
2475 int32_t userId = 1000;
2476 StoreInfo info;
2477 info.instanceId = 0;
2478 info.bundleName = TEST_CLOUD_BUNDLE;
2479 info.storeName = TEST_CLOUD_BUNDLE;
2480 info.user = userId;
2481 info.path = TEST_CLOUD_PATH;
2482 StoreMetaData meta(info);
2483 meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
2484 MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta, true);
2485 DistributedRdb::RdbQuery query;
2486 auto [status, cursor] = cloudServiceImpl_->PreShare(info, query);
2487 EXPECT_EQ(status, GeneralError::E_ERROR);
2488 }
2489
2490 /**
2491 * @tc.name: InitSubTask
2492 * @tc.desc: Test the InitSubTask with invalid parameters
2493 * @tc.type: FUNC
2494 * @tc.require:
2495 */
2496 HWTEST_F(CloudDataTest, InitSubTask, TestSize.Level0)
2497 {
2498 uint64_t minInterval = 0;
2499 uint64_t expire = 24 * 60 * 60 * 1000; // 24hours, ms
2500 ExecutorPool::TaskId taskId = 100;
2501 Subscription sub;
2502 sub.expiresTime.insert_or_assign(TEST_CLOUD_BUNDLE, expire);
2503 std::shared_ptr<ExecutorPool> executor = std::move(cloudServiceImpl_->executor_);
2504 cloudServiceImpl_->executor_ = nullptr;
2505 cloudServiceImpl_->InitSubTask(sub, minInterval);
2506 EXPECT_EQ(sub.GetMinExpireTime(), expire);
2507 cloudServiceImpl_->executor_ = std::move(executor);
2508 cloudServiceImpl_->subTask_ = taskId;
2509 cloudServiceImpl_->InitSubTask(sub, minInterval);
2510 EXPECT_NE(cloudServiceImpl_->subTask_, taskId);
2511 cloudServiceImpl_->subTask_ = taskId;
2512 cloudServiceImpl_->expireTime_ = 0;
2513 cloudServiceImpl_->InitSubTask(sub, minInterval);
2514 EXPECT_EQ(cloudServiceImpl_->subTask_, taskId);
2515 cloudServiceImpl_->subTask_ = ExecutorPool::INVALID_TASK_ID;
2516 cloudServiceImpl_->InitSubTask(sub, minInterval);
2517 EXPECT_NE(cloudServiceImpl_->subTask_, ExecutorPool::INVALID_TASK_ID);
2518 }
2519
2520 /**
2521 * @tc.name: DoSubscribe
2522 * @tc.desc: Test DoSubscribe functions with invalid parameter.
2523 * @tc.type: FUNC
2524 * @tc.require:
2525 */
2526 HWTEST_F(CloudDataTest, DoSubscribe, TestSize.Level0)
2527 {
2528 Subscription sub;
2529 sub.userId = cloudInfo_.user;
2530 MetaDataManager::GetInstance().SaveMeta(sub.GetKey(), sub, true);
2531 int user = cloudInfo_.user;
2532 auto status = cloudServiceImpl_->DoSubscribe(user, CloudSyncScene::ENABLE_CLOUD);
2533 EXPECT_FALSE(status);
2534 sub.id = "testId";
2535 MetaDataManager::GetInstance().SaveMeta(sub.GetKey(), sub, true);
2536 status = cloudServiceImpl_->DoSubscribe(user, CloudSyncScene::ENABLE_CLOUD);
2537 EXPECT_FALSE(status);
2538 sub.id = TEST_CLOUD_APPID;
2539 MetaDataManager::GetInstance().SaveMeta(sub.GetKey(), sub, true);
2540 status = cloudServiceImpl_->DoSubscribe(user, CloudSyncScene::ENABLE_CLOUD);
2541 EXPECT_FALSE(status);
2542 MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
2543 status = cloudServiceImpl_->DoSubscribe(user, CloudSyncScene::ENABLE_CLOUD);
2544 EXPECT_FALSE(status);
2545 }
2546
2547 /**
2548 * @tc.name: Report
2549 * @tc.desc: Test Report.
2550 * @tc.type: FUNC
2551 * @tc.require:
2552 */
2553 HWTEST_F(CloudDataTest, Report, TestSize.Level0)
2554 {
2555 auto cloudReport = std::make_shared<DistributedData::CloudReport>();
2556 auto prepareTraceId = cloudReport->GetPrepareTraceId(100);
2557 EXPECT_EQ(prepareTraceId, "");
2558 auto requestTraceId = cloudReport->GetRequestTraceId(100);
2559 EXPECT_EQ(requestTraceId, "");
2560 ReportParam reportParam{ 100, TEST_CLOUD_BUNDLE };
2561 auto ret = cloudReport->Report(reportParam);
2562 EXPECT_TRUE(ret);
2563 }
2564
2565 /**
2566 * @tc.name: IsOn
2567 * @tc.desc: Test IsOn.
2568 * @tc.type: FUNC
2569 * @tc.require:
2570 */
2571 HWTEST_F(CloudDataTest, IsOn, TestSize.Level0)
2572 {
2573 auto cloudServerMock = std::make_shared<CloudServerMock>();
2574 auto user = AccountDelegate::GetInstance()->GetUserByToken(OHOS::IPCSkeleton::GetCallingTokenID());
2575 auto [status, cloudInfo] = cloudServerMock->GetServerInfo(user, true);
2576 int32_t instanceId = 0;
2577 auto ret = cloudInfo.IsOn("", instanceId);
2578 EXPECT_FALSE(ret);
2579 }
2580
2581 /**
2582 * @tc.name: IsAllSwitchOff
2583 * @tc.desc: Test IsAllSwitchOff.
2584 * @tc.type: FUNC
2585 * @tc.require:
2586 */
2587 HWTEST_F(CloudDataTest, IsAllSwitchOff, TestSize.Level0)
2588 {
2589 auto cloudServerMock = std::make_shared<CloudServerMock>();
2590 auto user = AccountDelegate::GetInstance()->GetUserByToken(OHOS::IPCSkeleton::GetCallingTokenID());
2591 auto [status, cloudInfo] = cloudServerMock->GetServerInfo(user, true);
2592 auto ret = cloudInfo.IsAllSwitchOff();
2593 EXPECT_FALSE(ret);
2594 }
2595
2596 /**
2597 * @tc.name: GetMinExpireTime
2598 * @tc.desc: Test GetMinExpireTime.
2599 * @tc.type: FUNC
2600 * @tc.require:
2601 */
2602 HWTEST_F(CloudDataTest, GetMinExpireTime, TestSize.Level0)
2603 {
2604 uint64_t expire = 0;
2605 Subscription sub;
2606 sub.expiresTime.insert_or_assign(TEST_CLOUD_BUNDLE, expire);
2607 sub.GetMinExpireTime();
2608 expire = 24 * 60 * 60 * 1000;
2609 sub.expiresTime.insert_or_assign(TEST_CLOUD_BUNDLE, expire);
2610 expire = 24 * 60 * 60;
2611 sub.expiresTime.insert_or_assign("test_cloud_bundleName1", expire);
2612 EXPECT_EQ(sub.GetMinExpireTime(), expire);
2613 }
2614
2615 /**
2616 * @tc.name: GetTableNames
2617 * @tc.desc: Test GetTableNames.
2618 * @tc.type: FUNC
2619 * @tc.require:
2620 */
2621 HWTEST_F(CloudDataTest, GetTableNames, TestSize.Level0)
2622 {
2623 SchemaMeta::Database database;
2624 SchemaMeta::Table table;
2625 table.name = "test_cloud_table_name";
2626 table.alias = "test_cloud_table_alias";
2627 table.sharedTableName = "test_share_table_name";
2628 database.tables.emplace_back(table);
2629 auto tableNames = database.GetTableNames();
2630 EXPECT_EQ(tableNames.size(), 2);
2631 }
2632
2633 /**
2634 * @tc.name: BlobToAssets
2635 * @tc.desc: cloud_data_translate BlobToAsset error test.
2636 * @tc.type: FUNC
2637 * @tc.require:
2638 * @tc.author: SQL
2639 */
2640 HWTEST_F(CloudDataTest, BlobToAssets, TestSize.Level1)
2641 {
2642 CloudData::RdbCloudDataTranslate rdbTranslate;
2643 DistributedDB::Asset asset = {
2644 .name = "",
2645 .assetId = "",
2646 .subpath = "",
2647 .uri = "",
2648 .modifyTime = "",
2649 .createTime = "",
2650 .size = "",
2651 .hash = ""
2652 };
2653 std::vector<uint8_t> blob;
2654 auto result = rdbTranslate.BlobToAsset(blob);
2655 EXPECT_EQ(result, asset);
2656
2657 DistributedDB::Assets assets;
2658 blob = rdbTranslate.AssetsToBlob(assets);
2659 auto results = rdbTranslate.BlobToAssets(blob);
2660 EXPECT_EQ(results, assets);
2661 }
2662
2663 /**
2664 * @tc.name: GetPriorityLevel001
2665 * @tc.desc: GetPriorityLevel test
2666 * @tc.type: FUNC
2667 * @tc.require:
2668 * @tc.author:
2669 */
2670 HWTEST_F(CloudDataTest, GetPriorityLevel001, TestSize.Level1)
2671 {
__anonb11b2c810902(const Event &event) 2672 EventCenter::GetInstance().Subscribe(CloudEvent::LOCAL_CHANGE, [](const Event &event) {
2673 auto &evt = static_cast<const SyncEvent &>(event);
2674 auto mode = evt.GetMode();
2675 EXPECT_EQ(GeneralStore::GetPriorityLevel(GeneralStore::GetHighMode(static_cast<uint32_t>(mode))), 2);
2676 });
2677 DistributedRdb::RdbServiceImpl rdbServiceImpl;
2678 DistributedRdb::RdbSyncerParam param{ .bundleName_ = TEST_CLOUD_BUNDLE, .storeName_ = TEST_CLOUD_STORE };
2679 DistributedRdb::RdbService::Option option{ .mode = GeneralStore::SyncMode::CLOUD_CLOUD_FIRST, .isAsync = true };
2680 DistributedRdb::PredicatesMemo memo;
2681 memo.tables_ = { TEST_CLOUD_TABLE };
2682 rdbServiceImpl.DoCloudSync(param, option, memo, nullptr);
2683 }
2684
2685 /**
2686 * @tc.name: GetPriorityLevel002
2687 * @tc.desc: GetPriorityLevel test
2688 * @tc.type: FUNC
2689 * @tc.require:
2690 * @tc.author:
2691 */
2692 HWTEST_F(CloudDataTest, GetPriorityLevel002, TestSize.Level1)
2693 {
__anonb11b2c810a02(const Event &event) 2694 EventCenter::GetInstance().Subscribe(CloudEvent::LOCAL_CHANGE, [](const Event &event) {
2695 auto &evt = static_cast<const SyncEvent &>(event);
2696 auto mode = evt.GetMode();
2697 EXPECT_EQ(GeneralStore::GetPriorityLevel(GeneralStore::GetHighMode(static_cast<uint32_t>(mode))), 0);
2698 });
2699 DistributedRdb::RdbServiceImpl rdbServiceImpl;
2700 DistributedRdb::RdbSyncerParam param{ .bundleName_ = TEST_CLOUD_BUNDLE, .storeName_ = TEST_CLOUD_STORE };
2701 DistributedRdb::RdbService::Option option{ .mode = GeneralStore::SyncMode::CLOUD_TIME_FIRST, .isAsync = true };
2702 DistributedRdb::PredicatesMemo memo;
2703 memo.tables_ = { TEST_CLOUD_TABLE };
2704 rdbServiceImpl.DoCloudSync(param, option, memo, nullptr);
2705 }
2706
2707 /**
2708 * @tc.name: GetPriorityLevel003
2709 * @tc.desc: GetPriorityLevel test
2710 * @tc.type: FUNC
2711 * @tc.require:
2712 * @tc.author:
2713 */
2714 HWTEST_F(CloudDataTest, GetPriorityLevel003, TestSize.Level1)
2715 {
__anonb11b2c810b02(const Event &event) 2716 EventCenter::GetInstance().Subscribe(CloudEvent::LOCAL_CHANGE, [](const Event &event) {
2717 auto &evt = static_cast<const SyncEvent &>(event);
2718 auto mode = evt.GetMode();
2719 EXPECT_EQ(GeneralStore::GetPriorityLevel(GeneralStore::GetHighMode(static_cast<uint32_t>(mode))), 0);
2720 });
2721 DistributedRdb::RdbServiceImpl rdbServiceImpl;
2722 DistributedRdb::RdbSyncerParam param{ .bundleName_ = TEST_CLOUD_BUNDLE, .storeName_ = TEST_CLOUD_STORE };
2723 DistributedRdb::RdbService::Option option{ .mode = GeneralStore::SyncMode::CLOUD_CLOUD_FIRST, .isAsync = true };
2724 DistributedRdb::PredicatesMemo memo;
2725 rdbServiceImpl.DoCloudSync(param, option, memo, nullptr);
2726 }
2727
2728 /**
2729 * @tc.name: GetPriorityLevel004
2730 * @tc.desc: GetPriorityLevel test
2731 * @tc.type: FUNC
2732 * @tc.require:
2733 * @tc.author:
2734 */
2735 HWTEST_F(CloudDataTest, GetPriorityLevel004, TestSize.Level1)
2736 {
__anonb11b2c810c02(const Event &event) 2737 EventCenter::GetInstance().Subscribe(CloudEvent::LOCAL_CHANGE, [](const Event &event) {
2738 auto &evt = static_cast<const SyncEvent &>(event);
2739 auto mode = evt.GetMode();
2740 EXPECT_EQ(GeneralStore::GetPriorityLevel(GeneralStore::GetHighMode(static_cast<uint32_t>(mode))), 1);
2741 });
2742 DistributedRdb::RdbServiceImpl rdbServiceImpl;
2743 DistributedRdb::RdbSyncerParam param{ .bundleName_ = TEST_CLOUD_BUNDLE, .storeName_ = TEST_CLOUD_STORE };
2744 DistributedRdb::RdbService::Option option{ .mode = GeneralStore::SyncMode::CLOUD_CLOUD_FIRST,
2745 .seqNum = 0,
2746 .isAsync = true,
2747 .isAutoSync = true };
2748 DistributedRdb::PredicatesMemo memo;
2749 rdbServiceImpl.DoCloudSync(param, option, memo, nullptr);
2750 }
2751
2752 /**
2753 * @tc.name: UpdateSchemaFromHap001
2754 * @tc.desc: Test the UpdateSchemaFromHap with invalid user
2755 * @tc.type: FUNC
2756 * @tc.require:
2757 */
2758 HWTEST_F(CloudDataTest, UpdateSchemaFromHap001, TestSize.Level1)
2759 {
2760 ASSERT_NE(cloudServiceImpl_, nullptr);
2761 CloudData::CloudServiceImpl::HapInfo info = { .instIndex = 0, .bundleName = TEST_CLOUD_BUNDLE, .user = -1 };
2762 auto ret = cloudServiceImpl_->UpdateSchemaFromHap(info);
2763 EXPECT_EQ(ret, Status::ERROR);
2764 }
2765
2766 /**
2767 * @tc.name: UpdateSchemaFromHap002
2768 * @tc.desc: Test the UpdateSchemaFromHap with invalid bundleName
2769 * @tc.type: FUNC
2770 * @tc.require:
2771 */
2772 HWTEST_F(CloudDataTest, UpdateSchemaFromHap002, TestSize.Level1)
2773 {
2774 ASSERT_NE(cloudServiceImpl_, nullptr);
2775 CloudData::CloudServiceImpl::HapInfo info = { .instIndex = 0, .bundleName = "", .user = cloudInfo_.user };
2776 auto ret = cloudServiceImpl_->UpdateSchemaFromHap(info);
2777 EXPECT_EQ(ret, Status::ERROR);
2778 }
2779
2780 /**
2781 * @tc.name: UpdateSchemaFromHap003
2782 * @tc.desc: Test the UpdateSchemaFromHap with the schema application is not configured
2783 * @tc.type: FUNC
2784 * @tc.require:
2785 */
2786 HWTEST_F(CloudDataTest, UpdateSchemaFromHap003, TestSize.Level1)
2787 {
2788 ASSERT_NE(cloudServiceImpl_, nullptr);
2789 CloudData::CloudServiceImpl::HapInfo info = {
2790 .instIndex = 0, .bundleName = TEST_CLOUD_BUNDLE, .user = cloudInfo_.user
2791 };
2792 auto ret = cloudServiceImpl_->UpdateSchemaFromHap(info);
2793 EXPECT_EQ(ret, Status::SUCCESS);
2794 SchemaMeta schemaMeta;
2795 std::string schemaKey = CloudInfo::GetSchemaKey(info.user, info.bundleName, info.instIndex);
2796 ASSERT_TRUE(MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true));
2797 EXPECT_EQ(schemaMeta.version, schemaMeta_.version);
2798 }
2799
2800 /**
2801 * @tc.name: UpdateSchemaFromHap004
2802 * @tc.desc: Test the UpdateSchemaFromHap with valid parameter
2803 * @tc.type: FUNC
2804 * @tc.require:
2805 */
2806 HWTEST_F(CloudDataTest, UpdateSchemaFromHap004, TestSize.Level1)
2807 {
2808 ZLOGI("CloudServiceImplTest UpdateSchemaFromHap004 start");
2809 ASSERT_NE(cloudServiceImpl_, nullptr);
2810 CloudInfo::AppInfo exampleAppInfo;
2811 exampleAppInfo.bundleName = COM_EXAMPLE_TEST_CLOUD;
2812 exampleAppInfo.appId = COM_EXAMPLE_TEST_CLOUD;
2813 exampleAppInfo.version = 1;
2814 exampleAppInfo.cloudSwitch = true;
2815 CloudInfo cloudInfo;
2816 MetaDataManager::GetInstance().LoadMeta(cloudInfo_.GetKey(), cloudInfo, true);
2817 cloudInfo.apps[COM_EXAMPLE_TEST_CLOUD] = std::move(exampleAppInfo);
2818 MetaDataManager::GetInstance().SaveMeta(cloudInfo_.GetKey(), cloudInfo, true);
2819 CloudData::CloudServiceImpl::HapInfo info = {
2820 .instIndex = 0, .bundleName = COM_EXAMPLE_TEST_CLOUD, .user = cloudInfo_.user
2821 };
2822 auto ret = cloudServiceImpl_->UpdateSchemaFromHap(info);
2823 EXPECT_EQ(ret, Status::SUCCESS);
2824 SchemaMeta schemaMeta;
2825 std::string schemaKey = CloudInfo::GetSchemaKey(info.user, info.bundleName, info.instIndex);
2826 ASSERT_TRUE(MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true));
2827 EXPECT_EQ(schemaMeta.version, SCHEMA_VERSION);
2828 }
2829
2830 /**
2831 * @tc.name: UpdateClearWaterMark001
2832 * @tc.desc: Test UpdateClearWaterMark001 the database.version not found.
2833 * @tc.type: FUNC
2834 * @tc.require:
2835 */
2836 HWTEST_F(CloudDataTest, UpdateClearWaterMark001, TestSize.Level0)
2837 {
2838 ASSERT_NE(cloudServiceImpl_, nullptr);
2839 CloudData::CloudServiceImpl::HapInfo hapInfo = {
2840 .instIndex = 0, .bundleName = TEST_CLOUD_BUNDLE, .user = cloudInfo_.user
2841 };
2842 SchemaMeta::Database database;
2843 database.name = TEST_CLOUD_STORE;
2844 database.version = 1;
2845 SchemaMeta schemaMeta;
2846 schemaMeta.version = 1;
2847 schemaMeta.databases.push_back(database);
2848
2849 SchemaMeta::Database database1;
2850 database1.name = TEST_CLOUD_STORE_1;
2851 database1.version = 2;
2852 SchemaMeta newSchemaMeta;
2853 newSchemaMeta.version = 0;
2854 newSchemaMeta.databases.push_back(database1);
2855 cloudServiceImpl_->UpdateClearWaterMark(hapInfo, newSchemaMeta, schemaMeta);
2856
2857 CloudMark metaData;
2858 metaData.bundleName = hapInfo.bundleName;
2859 metaData.userId = hapInfo.user;
2860 metaData.index = hapInfo.instIndex;
2861 metaData.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
2862 metaData.storeId = database1.name;
2863 ASSERT_FALSE(MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData, true));
2864 }
2865
2866 /**
2867 * @tc.name: UpdateClearWaterMark002
2868 * @tc.desc: Test UpdateClearWaterMark002 the same database.version
2869 * @tc.type: FUNC
2870 * @tc.require:
2871 */
2872 HWTEST_F(CloudDataTest, UpdateClearWaterMark002, TestSize.Level0)
2873 {
2874 ASSERT_NE(cloudServiceImpl_, nullptr);
2875 CloudData::CloudServiceImpl::HapInfo hapInfo = {
2876 .instIndex = 0, .bundleName = TEST_CLOUD_BUNDLE, .user = cloudInfo_.user
2877 };
2878 SchemaMeta::Database database;
2879 database.name = TEST_CLOUD_STORE;
2880 database.version = 1;
2881 SchemaMeta schemaMeta;
2882 schemaMeta.version = 1;
2883 schemaMeta.databases.push_back(database);
2884
2885 SchemaMeta::Database database1;
2886 database1.name = TEST_CLOUD_STORE;
2887 database1.version = 1;
2888 SchemaMeta newSchemaMeta;
2889 newSchemaMeta.version = 0;
2890 newSchemaMeta.databases.push_back(database1);
2891 cloudServiceImpl_->UpdateClearWaterMark(hapInfo, newSchemaMeta, schemaMeta);
2892
2893 CloudMark metaData;
2894 metaData.bundleName = hapInfo.bundleName;
2895 metaData.userId = hapInfo.user;
2896 metaData.index = hapInfo.instIndex;
2897 metaData.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
2898 metaData.storeId = database1.name;
2899 ASSERT_FALSE(MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData, true));
2900 }
2901
2902 /**
2903 * @tc.name: UpdateClearWaterMark003
2904 * @tc.desc: Test UpdateClearWaterMark003 the different database.version
2905 * @tc.type: FUNC
2906 * @tc.require:
2907 */
2908 HWTEST_F(CloudDataTest, UpdateClearWaterMark003, TestSize.Level0)
2909 {
2910 ASSERT_NE(cloudServiceImpl_, nullptr);
2911 CloudData::CloudServiceImpl::HapInfo hapInfo = {
2912 .instIndex = 0, .bundleName = TEST_CLOUD_BUNDLE, .user = cloudInfo_.user
2913 };
2914 SchemaMeta::Database database;
2915 database.name = TEST_CLOUD_STORE;
2916 database.version = 1;
2917 SchemaMeta schemaMeta;
2918 schemaMeta.version = 1;
2919 schemaMeta.databases.push_back(database);
2920
2921 SchemaMeta::Database database1;
2922 database1.name = TEST_CLOUD_STORE;
2923 database1.version = 2;
2924 SchemaMeta newSchemaMeta;
2925 newSchemaMeta.version = 0;
2926 newSchemaMeta.databases.push_back(database1);
2927 cloudServiceImpl_->UpdateClearWaterMark(hapInfo, newSchemaMeta, schemaMeta);
2928
2929 CloudMark metaData;
2930 metaData.bundleName = hapInfo.bundleName;
2931 metaData.userId = hapInfo.user;
2932 metaData.index = hapInfo.instIndex;
2933 metaData.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
2934 metaData.storeId = database1.name;
2935 ASSERT_TRUE(MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData, true));
2936 EXPECT_TRUE(metaData.isClearWaterMark);
2937 MetaDataManager::GetInstance().DelMeta(metaData.GetKey(), true);
2938 }
2939
2940 /**
2941 * @tc.name: GetPrepareTraceId
2942 * @tc.desc: Test GetPrepareTraceId && GetUser
2943 * @tc.type: FUNC
2944 * @tc.require:
2945 */
2946 HWTEST_F(CloudDataTest, GetPrepareTraceId, TestSize.Level0)
2947 {
2948 SyncParam syncParam;
2949 syncParam.prepareTraceId = TEST_TRACE_ID;
2950 syncParam.user = EVT_USER;
__anonb11b2c810d02(const GenDetails &details) 2951 auto async = [](const GenDetails &details) {};
2952 SyncEvent::EventInfo eventInfo(syncParam, true, nullptr, async);
2953 StoreInfo storeInfo;
2954 SyncEvent evt(storeInfo, std::move(eventInfo));
2955 EXPECT_EQ(evt.GetUser(), EVT_USER);
2956 EXPECT_EQ(evt.GetPrepareTraceId(), TEST_TRACE_ID);
2957 }
2958
2959 /**
2960 * @tc.name: TryUpdateDeviceId001
2961 * @tc.desc: TryUpdateDeviceId test
2962 * @tc.type: FUNC
2963 * @tc.require:
2964 * @tc.author:
2965 */
2966 HWTEST_F(CloudDataTest, TryUpdateDeviceId001, TestSize.Level1)
2967 {
2968 DistributedRdb::RdbServiceImpl rdbServiceImpl;
2969 DistributedRdb::RdbSyncerParam param{ .bundleName_ = TEST_CLOUD_BUNDLE, .storeName_ = TEST_CLOUD_STORE };
2970 StoreMetaData oldMeta;
2971 oldMeta.deviceId = "oldUuidtest";
2972 oldMeta.user = "100";
2973 oldMeta.bundleName = "test_appid_001";
2974 oldMeta.storeId = "test_storeid_001";
2975 oldMeta.isNeedUpdateDeviceId = true;
2976 oldMeta.storeType = StoreMetaData::StoreType::STORE_RELATIONAL_BEGIN;
2977 bool isSuccess = MetaDataManager::GetInstance().SaveMeta(oldMeta.GetKeyWithoutPath(), oldMeta);
2978 EXPECT_EQ(isSuccess, true);
2979 StoreMetaData meta1 = oldMeta;
2980 auto ret = rdbServiceImpl.TryUpdateDeviceId(param, oldMeta, meta1);
2981 EXPECT_EQ(ret, true);
2982 MetaDataManager::GetInstance().DelMeta(oldMeta.GetKeyWithoutPath());
2983 }
2984
2985 /**
2986 * @tc.name: TryUpdateDeviceId002
2987 * @tc.desc: TryUpdateDeviceId test
2988 * @tc.type: FUNC
2989 * @tc.require:
2990 * @tc.author:
2991 */
2992 HWTEST_F(CloudDataTest, TryUpdateDeviceId002, TestSize.Level1)
2993 {
2994 DistributedRdb::RdbServiceImpl rdbServiceImpl;
2995 DistributedRdb::RdbSyncerParam param{ .bundleName_ = TEST_CLOUD_BUNDLE, .storeName_ = TEST_CLOUD_STORE };
2996 StoreMetaData oldMeta;
2997 oldMeta.deviceId = "oldUuidtest";
2998 oldMeta.user = "100";
2999 oldMeta.bundleName = "test_appid_001";
3000 oldMeta.storeId = "test_storeid_001";
3001 oldMeta.isNeedUpdateDeviceId = false;
3002 oldMeta.storeType = StoreMetaData::StoreType::STORE_RELATIONAL_BEGIN;
3003 bool isSuccess = MetaDataManager::GetInstance().SaveMeta(oldMeta.GetKeyWithoutPath(), oldMeta);
3004 EXPECT_EQ(isSuccess, true);
3005 StoreMetaData meta1 = oldMeta;
3006 auto ret = rdbServiceImpl.TryUpdateDeviceId(param, oldMeta, meta1);
3007 EXPECT_EQ(ret, true);
3008 MetaDataManager::GetInstance().DelMeta(oldMeta.GetKeyWithoutPath());
3009 }
3010
3011 /**
3012 * @tc.name: TryUpdateDeviceId003
3013 * @tc.desc: TryUpdateDeviceId test
3014 * @tc.type: FUNC
3015 * @tc.require:
3016 * @tc.author:
3017 */
3018 HWTEST_F(CloudDataTest, TryUpdateDeviceId003, TestSize.Level1)
3019 {
3020 DistributedRdb::RdbServiceImpl rdbServiceImpl;
3021 DistributedRdb::RdbSyncerParam param{ .bundleName_ = TEST_CLOUD_BUNDLE, .storeName_ = TEST_CLOUD_STORE };
3022 StoreMetaData oldMeta;
3023 oldMeta.deviceId = "oldUuidtest";
3024 oldMeta.user = "100";
3025 oldMeta.bundleName = "test_appid_001";
3026 oldMeta.storeId = "test_storeid_001";
3027 oldMeta.isNeedUpdateDeviceId = true;
3028 oldMeta.storeType = StoreMetaData::StoreType::STORE_RELATIONAL_END;
3029 bool isSuccess = MetaDataManager::GetInstance().SaveMeta(oldMeta.GetKeyWithoutPath(), oldMeta);
3030 EXPECT_EQ(isSuccess, true);
3031 StoreMetaData meta1 = oldMeta;
3032 auto ret = rdbServiceImpl.TryUpdateDeviceId(param, oldMeta, meta1);
3033 EXPECT_EQ(ret, true);
3034 MetaDataManager::GetInstance().DelMeta(oldMeta.GetKeyWithoutPath());
3035 }
3036
3037 /**
3038 * @tc.name: TryUpdateDeviceId004
3039 * @tc.desc: TryUpdateDeviceId test
3040 * @tc.type: FUNC
3041 * @tc.require:
3042 * @tc.author:
3043 */
3044 HWTEST_F(CloudDataTest, TryUpdateDeviceId004, TestSize.Level1)
3045 {
3046 DistributedRdb::RdbServiceImpl rdbServiceImpl;
3047 DistributedRdb::RdbSyncerParam param{ .bundleName_ = TEST_CLOUD_BUNDLE, .storeName_ = TEST_CLOUD_STORE };
3048 StoreMetaData oldMeta;
3049 oldMeta.deviceId = "oldUuidtest";
3050 oldMeta.user = "100";
3051 oldMeta.bundleName = "test_appid_001";
3052 oldMeta.storeId = "test_storeid_001";
3053 oldMeta.isNeedUpdateDeviceId = false;
3054 oldMeta.storeType = StoreMetaData::StoreType::STORE_RELATIONAL_END;
3055 bool isSuccess = MetaDataManager::GetInstance().SaveMeta(oldMeta.GetKeyWithoutPath(), oldMeta);
3056 EXPECT_EQ(isSuccess, true);
3057 StoreMetaData meta1 = oldMeta;
3058 auto ret = rdbServiceImpl.TryUpdateDeviceId(param, oldMeta, meta1);
3059 EXPECT_EQ(ret, true);
3060 MetaDataManager::GetInstance().DelMeta(oldMeta.GetKeyWithoutPath());
3061 }
3062
3063 /**
3064 * @tc.name: OnInitialize
3065 * @tc.desc: OnInitialize test
3066 * @tc.type: FUNC
3067 * @tc.require:
3068 * @tc.author:
3069 */
3070 HWTEST_F(CloudDataTest, OnInitialize, TestSize.Level1)
3071 {
3072 auto code = cloudServiceImpl_->OnInitialize();
3073 EXPECT_EQ(code, E_OK);
3074 }
3075
3076 /**
3077 * @tc.name: CleanWaterVersion
3078 * @tc.desc: CleanWaterVersion test
3079 * @tc.type: FUNC
3080 * @tc.require:
3081 * @tc.author:
3082 */
3083 HWTEST_F(CloudDataTest, CleanWaterVersion, TestSize.Level1)
3084 {
3085 auto ret = cloudServiceImpl_->CleanWaterVersion(200);
3086 EXPECT_FALSE(ret);
3087 ret = cloudServiceImpl_->CleanWaterVersion(
3088 AccountDelegate::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()));
3089 EXPECT_TRUE(ret);
3090 }
3091
3092 /**
3093 * @tc.name: ConvertGenDetailsCode
3094 * @tc.desc: Test ConvertGenDetailsCode function.
3095 * @tc.type: FUNC
3096 * @tc.require:
3097 */
3098 HWTEST_F(CloudDataTest, ConvertGenDetailsCode, TestSize.Level0)
3099 {
3100 DistributedData::GenDetails result;
3101 GenProgressDetail detail;
3102 detail.progress = GenProgress::SYNC_IN_PROGRESS;
3103 detail.code = 100;
3104 result.insert(std::make_pair("test", detail));
3105 auto details = CloudData::SyncManager::ConvertGenDetailsCode(result);
3106 EXPECT_TRUE(details["test"].code == E_ERROR);
3107
3108 DistributedData::GenDetails result1;
3109 GenProgressDetail detail1;
3110 detail1.progress = GenProgress::SYNC_IN_PROGRESS;
3111 detail1.code = E_ERROR;
3112 result1.insert(std::make_pair("test", detail1));
3113 details = CloudData::SyncManager::ConvertGenDetailsCode(result1);
3114 EXPECT_TRUE(details["test"].code == E_ERROR);
3115
3116 DistributedData::GenDetails result2;
3117 GenProgressDetail detail2;
3118 detail2.progress = GenProgress::SYNC_IN_PROGRESS;
3119 detail2.code = E_OK;
3120 result2.insert(std::make_pair("test", detail2));
3121 details = CloudData::SyncManager::ConvertGenDetailsCode(result2);
3122 EXPECT_TRUE(details["test"].code == E_OK);
3123
3124 DistributedData::GenDetails result3;
3125 GenProgressDetail detail3;
3126 detail3.progress = GenProgress::SYNC_IN_PROGRESS;
3127 detail3.code = E_BLOCKED_BY_NETWORK_STRATEGY;
3128 result3.insert(std::make_pair("test", detail3));
3129 details = CloudData::SyncManager::ConvertGenDetailsCode(result3);
3130 EXPECT_TRUE(details["test"].code == E_BLOCKED_BY_NETWORK_STRATEGY);
3131
3132 DistributedData::GenDetails result4;
3133 GenProgressDetail detail4;
3134 detail4.progress = GenProgress::SYNC_IN_PROGRESS;
3135 detail4.code = E_BUSY;
3136 result4.insert(std::make_pair("test", detail4));
3137 details = CloudData::SyncManager::ConvertGenDetailsCode(result4);
3138 EXPECT_TRUE(details["test"].code == E_ERROR);
3139 }
3140
3141 /**
3142 * @tc.name: ConvertValidGeneralCode
3143 * @tc.desc: Test ConvertValidGeneralCode function.
3144 * @tc.type: FUNC
3145 * @tc.require:
3146 */
3147 HWTEST_F(CloudDataTest, GetValidGeneralCode, TestSize.Level0)
3148 {
3149 auto ret = CloudData::SyncManager::ConvertValidGeneralCode(E_OK);
3150 EXPECT_TRUE(ret == E_OK);
3151 ret = CloudData::SyncManager::ConvertValidGeneralCode(E_ERROR);
3152 EXPECT_TRUE(ret == E_ERROR);
3153 ret = CloudData::SyncManager::ConvertValidGeneralCode(E_NETWORK_ERROR);
3154 EXPECT_TRUE(ret == E_NETWORK_ERROR);
3155 ret = CloudData::SyncManager::ConvertValidGeneralCode(E_CLOUD_DISABLED);
3156 EXPECT_TRUE(ret == E_CLOUD_DISABLED);
3157 ret = CloudData::SyncManager::ConvertValidGeneralCode(E_LOCKED_BY_OTHERS);
3158 EXPECT_TRUE(ret == E_LOCKED_BY_OTHERS);
3159 ret = CloudData::SyncManager::ConvertValidGeneralCode(E_RECODE_LIMIT_EXCEEDED);
3160 EXPECT_TRUE(ret == E_RECODE_LIMIT_EXCEEDED);
3161 ret = CloudData::SyncManager::ConvertValidGeneralCode(E_NO_SPACE_FOR_ASSET);
3162 EXPECT_TRUE(ret == E_NO_SPACE_FOR_ASSET);
3163 ret = CloudData::SyncManager::ConvertValidGeneralCode(E_BLOCKED_BY_NETWORK_STRATEGY);
3164 EXPECT_TRUE(ret == E_BLOCKED_BY_NETWORK_STRATEGY);
3165 ret = CloudData::SyncManager::ConvertValidGeneralCode(E_BUSY);
3166 EXPECT_TRUE(ret == E_ERROR);
3167 ret = CloudData::SyncManager::ConvertValidGeneralCode(E_SYNC_TASK_MERGED);
3168 EXPECT_TRUE(ret == E_ERROR);
3169 }
3170 } // namespace DistributedDataTest
3171 } // namespace OHOS::Test