1 /* 2 * Copyright (c) 2023 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 #include "cloud_syncer.h" 16 17 #include <gtest/gtest.h> 18 19 #include "cloud_syncer_test.h" 20 #include "cloud_store_types.h" 21 #include "db_errno.h" 22 #include "distributeddb_tools_unit_test.h" 23 #include "relational_store_manager.h" 24 #include "distributeddb_data_generate_unit_test.h" 25 #include "relational_sync_able_storage.h" 26 #include "relational_store_instance.h" 27 #include "sqlite_relational_store.h" 28 #include "log_table_manager_factory.h" 29 30 using namespace testing::ext; 31 using namespace DistributedDB; 32 using namespace DistributedDBUnitTest; 33 using namespace std; 34 35 namespace { 36 constexpr auto FIELD_ID = "id"; 37 constexpr auto FIELD_NAME = "name"; 38 constexpr auto FIELD_HOUSE = "house"; 39 constexpr auto FIELD_CARS = "cars"; 40 const string STORE_ID = "Relational_Store_ID"; 41 const string TABLE_NAME = "cloudData"; 42 string STORE_PATH = "./g_store.db"; 43 string TEST_DIR; 44 DistributedDB::RelationalStoreManager g_mgr(APP_ID, USER_ID); 45 RelationalStoreDelegate *g_delegate = nullptr; 46 IRelationalStore *g_store = nullptr; 47 std::shared_ptr<TestStorageProxy> g_storageProxy = nullptr; 48 std::shared_ptr<TestCloudSyncer> g_cloudSyncer = nullptr; 49 Asset a1; 50 Asset a1Changed; 51 Asset a2; 52 Asset a2Changed; 53 Asset a3; 54 Asset a3Changed; 55 Asset a4; 56 Asset a4Changed; 57 Asset a5; 58 Asset a5Changed; 59 const std::vector<Field> ASSET_FIELDS = { 60 {FIELD_HOUSE, TYPE_INDEX<Asset>, false}, {FIELD_CARS, TYPE_INDEX<Assets>, false} 61 }; 62 VBucket DATA_BASELINE; 63 VBucket DATA_EMPTY_ASSET; 64 VBucket DATA_ASSET_SAME_NAME_BUT_CHANGE; 65 VBucket DATA_ASSETS_SAME_NAME_PARTIALLY_CHANGED; 66 VBucket DATA_ALL_SAME; 67 VBucket DATA_ASSETS_MORE_FIELD; 68 VBucket DATA_EMPTY; 69 VBucket DATA_ASSETS_DIFFERENT_FIELD; 70 VBucket DATA_ASSETS_DIFFERENT_CHANGED_FIELD; 71 VBucket DATA_ASSETS_SAME_NAME_ALL_CHANGED; 72 VBucket DATA_ASSETS_ASSET_SAME_NAME; 73 VBucket DATA_NULL_ASSET; 74 VBucket DATA_ASSET_IN_ASSETS; 75 VBucket DATA_NULL_ASSETS; 76 VBucket DATA_ALL_NULL_ASSETS; 77 VBucket DATA_EMPTY_ASSETS; 78 VBucket DATA_UPDATE_DELTE_NOCHANGE_INSERT; 79 VBucket DATA_SAME_NAME_ASSETS; 80 GenAsset(std::string name,std::string hash)81 Asset GenAsset(std::string name, std::string hash) 82 { 83 Asset asset; 84 asset.name = name; 85 asset.hash = hash; 86 return asset; 87 } 88 GenDatum(int64_t id,std::string name,Type asset,Type assets)89 VBucket GenDatum(int64_t id, std::string name, Type asset, Type assets) 90 { 91 VBucket datum; 92 datum[FIELD_ID] = id; 93 datum[FIELD_NAME] = name; 94 datum[FIELD_HOUSE] = asset; 95 datum[FIELD_CARS] = assets; 96 return datum; 97 } 98 GenData()99 void GenData() 100 { 101 a1 = GenAsset("mansion", "mansion1"); 102 a1Changed = GenAsset("mansion", "mansion1Changed"); 103 a2 = GenAsset("suv", "suv1"); 104 a2Changed = GenAsset("suv", "suv1Changed"); 105 a3 = GenAsset("truck", "truck1"); 106 a3Changed = GenAsset("truck", "truck1Changed"); 107 a4 = GenAsset("sedan", "sedan1"); 108 a4Changed = GenAsset("sedan", "sedan1Changed"); 109 a5 = GenAsset("trucker", "truck1"); 110 a5Changed = GenAsset("trucker", "truck1Changed"); 111 DATA_EMPTY.clear(); 112 DATA_BASELINE = GenDatum(1, "Jack", a1, Assets({a2, a3, a4})); // id is 1 113 DATA_EMPTY_ASSET = GenDatum(2, "PoorGuy", a1, Assets({})); // id is 2 114 DATA_EMPTY_ASSET.erase(FIELD_HOUSE); 115 DATA_ASSET_SAME_NAME_BUT_CHANGE = GenDatum(3, "Alice", a1Changed, Assets({a2, a3, a4})); // id is 3 116 DATA_ASSETS_SAME_NAME_PARTIALLY_CHANGED = GenDatum(4, "David", a1, Assets({a2, a3Changed, a4})); // id is 4 117 DATA_ALL_SAME = GenDatum(5, "Marry", a1, Assets({a2, a3, a4})); // id is 5 118 DATA_ASSETS_MORE_FIELD = GenDatum(6, "Carl", a1, Assets({a2, a3, a4, a5})); // id is 6 119 DATA_ASSETS_DIFFERENT_FIELD = GenDatum(7, "Carllol", a1, Assets({a2, a3, a5})); // id is 7 120 DATA_ASSETS_DIFFERENT_CHANGED_FIELD = GenDatum(8, "Carllol", a1, Assets({a2, a3Changed, a5})); // id is 8 121 DATA_ASSETS_SAME_NAME_ALL_CHANGED = GenDatum( 122 9, "Lob", a1Changed, Assets({a2Changed, a3Changed, a4Changed})); // id is 9 123 DATA_ASSETS_ASSET_SAME_NAME = GenDatum(10, "Lob2", a1, Assets({a1, a2, a3})); // id is 10 124 std::monostate nil; 125 DATA_NULL_ASSET = GenDatum(11, "Lob3", nil, Assets({a1, a2, a3})); // id is 11 126 DATA_ASSET_IN_ASSETS = GenDatum(12, "Lob4", Assets({a1}), Assets({a2, a3, a4})); // id is 12 127 DATA_NULL_ASSETS = GenDatum(13, "Lob5", Assets({a1}), nil); // id is 13 128 DATA_ALL_NULL_ASSETS = GenDatum(14, "Nico", nil, nil); // id is 14 129 DATA_EMPTY_ASSETS = GenDatum(15, "Lob6", a1, Assets({})); // id is 15 130 DATA_EMPTY_ASSETS.erase(FIELD_CARS); 131 DATA_UPDATE_DELTE_NOCHANGE_INSERT = GenDatum(16, "Nico321", nil, Assets({a2Changed, a4, a5})); // id is 16 132 DATA_SAME_NAME_ASSETS = GenDatum(16, "Nico156", nil, Assets({a1, a1Changed})); // id is 16 133 } 134 CreateDB()135 void CreateDB() 136 { 137 sqlite3 *db = nullptr; 138 int errCode = sqlite3_open(STORE_PATH.c_str(), &db); 139 if (errCode != SQLITE_OK) { 140 LOGE("open db failed:%d", errCode); 141 sqlite3_close(db); 142 return; 143 } 144 const string sql = 145 "PRAGMA journal_mode=WAL;"; 146 ASSERT_EQ(SQLiteUtils::ExecuteRawSQL(db, sql.c_str()), E_OK); 147 sqlite3_close(db); 148 } 149 InitStoreProp(const std::string & storePath,const std::string & appId,const std::string & userId,RelationalDBProperties & properties)150 void InitStoreProp(const std::string &storePath, const std::string &appId, const std::string &userId, 151 RelationalDBProperties &properties) 152 { 153 properties.SetStringProp(RelationalDBProperties::DATA_DIR, storePath); 154 properties.SetStringProp(RelationalDBProperties::APP_ID, appId); 155 properties.SetStringProp(RelationalDBProperties::USER_ID, userId); 156 properties.SetStringProp(RelationalDBProperties::STORE_ID, STORE_ID); 157 std::string identifier = userId + "-" + appId + "-" + STORE_ID; 158 std::string hashIdentifier = DBCommon::TransferHashString(identifier); 159 properties.SetStringProp(RelationalDBProperties::IDENTIFIER_DATA, hashIdentifier); 160 } 161 GetRelationalStore()162 const RelationalSyncAbleStorage *GetRelationalStore() 163 { 164 RelationalDBProperties properties; 165 InitStoreProp(STORE_PATH, APP_ID, USER_ID, properties); 166 int errCode = E_OK; 167 g_store = RelationalStoreInstance::GetDataBase(properties, errCode); 168 if (g_store == nullptr) { 169 LOGE("Get db failed:%d", errCode); 170 return nullptr; 171 } 172 return static_cast<SQLiteRelationalStore *>(g_store)->GetStorageEngine(); 173 } 174 175 class DistributedDBCloudAssetCompareTest : public testing::Test { 176 public: 177 static void SetUpTestCase(void); 178 static void TearDownTestCase(void); 179 void SetUp(); 180 void TearDown(); 181 }; 182 SetUpTestCase(void)183 void DistributedDBCloudAssetCompareTest::SetUpTestCase(void) 184 { 185 } 186 TearDownTestCase(void)187 void DistributedDBCloudAssetCompareTest::TearDownTestCase(void) 188 { 189 } 190 SetUp(void)191 void DistributedDBCloudAssetCompareTest::SetUp(void) 192 { 193 DistributedDBToolsUnitTest::PrintTestCaseInfo(); 194 LOGD("Test dir is %s", TEST_DIR.c_str()); 195 CreateDB(); 196 ASSERT_EQ(g_mgr.OpenStore(STORE_PATH, STORE_ID, RelationalStoreDelegate::Option {}, g_delegate), DBStatus::OK); 197 ASSERT_NE(g_delegate, nullptr); 198 g_storageProxy = std::make_shared<TestStorageProxy>((ICloudSyncStorageInterface *) GetRelationalStore()); 199 ASSERT_NE(g_storageProxy, nullptr); 200 g_cloudSyncer = std::make_shared<TestCloudSyncer>(g_storageProxy); 201 ASSERT_NE(g_cloudSyncer, nullptr); 202 g_cloudSyncer->SetAssetFields(TABLE_NAME, ASSET_FIELDS); 203 GenData(); 204 } 205 TearDown(void)206 void DistributedDBCloudAssetCompareTest::TearDown(void) 207 { 208 if (g_delegate != nullptr) { 209 EXPECT_EQ(g_mgr.CloseStore(g_delegate), DBStatus::OK); 210 g_delegate = nullptr; 211 g_storageProxy = nullptr; 212 g_cloudSyncer = nullptr; 213 } 214 if (DistributedDBToolsUnitTest::RemoveTestDbFiles(TEST_DIR) != 0) { 215 LOGE("rm test db files error."); 216 } 217 } 218 IsAssetEq(Asset & target,Asset & expected)219 static bool IsAssetEq(Asset &target, Asset &expected) 220 { 221 if (target.name != expected.name || 222 target.flag != expected.flag || 223 target.status != expected.status) { 224 return false; 225 } 226 return true; 227 } 228 CheckAssetDownloadList(std::string fieldName,std::map<std::string,Assets> & target,std::map<std::string,Assets> & expected)229 static bool CheckAssetDownloadList(std::string fieldName, std::map<std::string, Assets> &target, 230 std::map<std::string, Assets> &expected) 231 { 232 if (target[fieldName].size() != expected[fieldName].size()) { 233 return false; 234 } 235 for (size_t i = 0; i < target[fieldName].size(); i++) { 236 if (!IsAssetEq(target[fieldName][i], expected[fieldName][i])) { 237 return false; 238 } 239 } 240 return true; 241 } 242 TagAsset(AssetOpType flag,AssetStatus status,Asset & asset)243 static void TagAsset(AssetOpType flag, AssetStatus status, Asset &asset) 244 { 245 asset.flag = static_cast<uint32_t>(flag); 246 asset.status = static_cast<uint32_t>(status); 247 } 248 249 /** 250 * @tc.name: AssetCmpTest001 251 * @tc.desc: 252 * @tc.type: FUNC 253 * @tc.require: 254 * @tc.author: wanyi 255 */ 256 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest001, TestSize.Level0) 257 { 258 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord(DATA_BASELINE, DATA_EMPTY); 259 std::map<std::string, Assets> expectedList; 260 TagAsset(AssetOpType::INSERT, AssetStatus::DOWNLOADING, a1); 261 TagAsset(AssetOpType::INSERT, AssetStatus::DOWNLOADING, a2); 262 TagAsset(AssetOpType::INSERT, AssetStatus::DOWNLOADING, a3); 263 TagAsset(AssetOpType::INSERT, AssetStatus::DOWNLOADING, a4); 264 expectedList[FIELD_HOUSE] = { a1 }; 265 expectedList[FIELD_CARS] = { a2, a3, a4 }; 266 ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); 267 ASSERT_TRUE(CheckAssetDownloadList(FIELD_CARS, assetList, expectedList)); 268 } 269 270 /** 271 * @tc.name: AssetCmpTest002 272 * @tc.desc: 273 * @tc.type: FUNC 274 * @tc.require: 275 * @tc.author: wanyi 276 */ 277 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest002, TestSize.Level0) 278 { 279 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord(DATA_BASELINE, DATA_EMPTY_ASSET); 280 std::map<std::string, Assets> expectedList; 281 TagAsset(AssetOpType::INSERT, AssetStatus::DOWNLOADING, a1); 282 TagAsset(AssetOpType::INSERT, AssetStatus::DOWNLOADING, a2); 283 TagAsset(AssetOpType::INSERT, AssetStatus::DOWNLOADING, a3); 284 TagAsset(AssetOpType::INSERT, AssetStatus::DOWNLOADING, a4); 285 expectedList[FIELD_HOUSE] = { a1 }; 286 expectedList[FIELD_CARS] = { a2, a3, a4 }; 287 ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); 288 ASSERT_TRUE(CheckAssetDownloadList(FIELD_CARS, assetList, expectedList)); 289 } 290 291 /** 292 * @tc.name: AssetCmpTest003 293 * @tc.desc: 294 * @tc.type: FUNC 295 * @tc.require: 296 * @tc.author: wanyi 297 */ 298 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest003, TestSize.Level0) 299 { 300 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord(DATA_BASELINE, DATA_ASSET_SAME_NAME_BUT_CHANGE); 301 std::map<std::string, Assets> expectedList; 302 TagAsset(AssetOpType::UPDATE, AssetStatus::DOWNLOADING, a1); 303 expectedList[FIELD_HOUSE] = { a1 }; 304 expectedList[FIELD_CARS] = { a2, a3, a4 }; 305 ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); 306 ASSERT_TRUE(CheckAssetDownloadList(FIELD_CARS, assetList, expectedList)); 307 } 308 309 /** 310 * @tc.name: AssetCmpTest004 311 * @tc.desc: 312 * @tc.type: FUNC 313 * @tc.require: 314 * @tc.author: wanyi 315 */ 316 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest004, TestSize.Level0) 317 { 318 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 319 DATA_BASELINE, DATA_ASSETS_SAME_NAME_PARTIALLY_CHANGED); 320 std::map<std::string, Assets> expectedList; 321 TagAsset(AssetOpType::UPDATE, AssetStatus::DOWNLOADING, a3); 322 expectedList[FIELD_HOUSE] = {}; 323 expectedList[FIELD_CARS] = { a2, a3, a4 }; 324 ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); 325 ASSERT_TRUE(CheckAssetDownloadList(FIELD_CARS, assetList, expectedList)); 326 } 327 328 /** 329 * @tc.name: AssetCmpTest005 330 * @tc.desc: 331 * @tc.type: FUNC 332 * @tc.require: 333 * @tc.author: wanyi 334 */ 335 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest005, TestSize.Level0) 336 { 337 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 338 DATA_BASELINE, DATA_ALL_SAME); 339 std::map<std::string, Assets> expectedList; 340 expectedList[FIELD_HOUSE] = {}; 341 expectedList[FIELD_CARS] = { a2, a3, a4 }; 342 ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); 343 ASSERT_TRUE(CheckAssetDownloadList(FIELD_CARS, assetList, expectedList)); 344 } 345 346 /** 347 * @tc.name: AssetCmpTest006 348 * @tc.desc: 349 * @tc.type: FUNC 350 * @tc.require: 351 * @tc.author: wanyi 352 */ 353 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest006, TestSize.Level0) 354 { 355 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 356 DATA_BASELINE, DATA_ASSETS_MORE_FIELD); 357 std::map<std::string, Assets> expectedList; 358 TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a5); 359 expectedList[FIELD_HOUSE] = {}; 360 expectedList[FIELD_CARS] = { a2, a3, a4, a5 }; 361 ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); 362 ASSERT_TRUE(CheckAssetDownloadList(FIELD_CARS, assetList, expectedList)); 363 } 364 365 /** 366 * @tc.name: AssetCmpTest007 367 * @tc.desc: 368 * @tc.type: FUNC 369 * @tc.require: 370 * @tc.author: wanyi 371 */ 372 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest007, TestSize.Level0) 373 { 374 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 375 DATA_BASELINE, DATA_ASSETS_DIFFERENT_FIELD); 376 std::map<std::string, Assets> expectedList; 377 TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a5); 378 TagAsset(AssetOpType::INSERT, AssetStatus::DOWNLOADING, a4); 379 expectedList[FIELD_HOUSE] = {}; 380 expectedList[FIELD_CARS] = { a2, a3, a5, a4 }; 381 ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); 382 ASSERT_TRUE(CheckAssetDownloadList(FIELD_CARS, assetList, expectedList)); 383 } 384 385 /** 386 * @tc.name: AssetCmpTest008 387 * @tc.desc: 388 * @tc.type: FUNC 389 * @tc.require: 390 * @tc.author: wanyi 391 */ 392 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest008, TestSize.Level0) 393 { 394 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 395 DATA_BASELINE, DATA_ASSETS_DIFFERENT_CHANGED_FIELD); 396 std::map<std::string, Assets> expectedList; 397 TagAsset(AssetOpType::UPDATE, AssetStatus::DOWNLOADING, a3); 398 TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a5); 399 TagAsset(AssetOpType::INSERT, AssetStatus::DOWNLOADING, a4); 400 expectedList[FIELD_HOUSE] = {}; 401 expectedList[FIELD_CARS] = { a2, a3, a5, a4 }; 402 ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); 403 ASSERT_TRUE(CheckAssetDownloadList(FIELD_CARS, assetList, expectedList)); 404 } 405 406 /** 407 * @tc.name: AssetCmpTest009 408 * @tc.desc: 409 * @tc.type: FUNC 410 * @tc.require: 411 * @tc.author: wanyi 412 */ 413 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest009, TestSize.Level0) 414 { 415 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 416 DATA_BASELINE, DATA_ASSETS_SAME_NAME_ALL_CHANGED); 417 std::map<std::string, Assets> expectedList; 418 TagAsset(AssetOpType::UPDATE, AssetStatus::DOWNLOADING, a1); 419 TagAsset(AssetOpType::UPDATE, AssetStatus::DOWNLOADING, a2); 420 TagAsset(AssetOpType::UPDATE, AssetStatus::DOWNLOADING, a3); 421 TagAsset(AssetOpType::UPDATE, AssetStatus::DOWNLOADING, a4); 422 expectedList[FIELD_HOUSE] = { a1 }; 423 expectedList[FIELD_CARS] = { a2, a3, a4 }; 424 ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); 425 ASSERT_TRUE(CheckAssetDownloadList(FIELD_CARS, assetList, expectedList)); 426 } 427 428 /** 429 * @tc.name: AssetCmpTest010 430 * @tc.desc: 431 * @tc.type: FUNC 432 * @tc.require: 433 * @tc.author: wanyi 434 */ 435 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest010, TestSize.Level0) 436 { 437 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 438 DATA_EMPTY_ASSET, DATA_BASELINE); 439 std::map<std::string, Assets> expectedList; 440 TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a1); 441 TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a2); 442 TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a3); 443 TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a4); 444 expectedList[FIELD_HOUSE] = { a1 }; 445 expectedList[FIELD_CARS] = { a2, a3, a4 }; 446 ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); 447 ASSERT_TRUE(CheckAssetDownloadList(FIELD_CARS, assetList, expectedList)); 448 } 449 450 /** 451 * @tc.name: AssetCmpTest011 452 * @tc.desc: 453 * @tc.type: FUNC 454 * @tc.require: 455 * @tc.author: wanyi 456 */ 457 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest011, TestSize.Level0) 458 { 459 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 460 DATA_EMPTY_ASSET, DATA_ASSETS_ASSET_SAME_NAME); 461 std::map<std::string, Assets> expectedList; 462 TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a1); 463 TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a2); 464 TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a3); 465 expectedList[FIELD_HOUSE] = { a1 }; 466 expectedList[FIELD_CARS] = { a1, a2, a3 }; 467 ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); 468 ASSERT_TRUE(CheckAssetDownloadList(FIELD_CARS, assetList, expectedList)); 469 } 470 471 /** 472 * @tc.name: AssetCmpTest012 473 * @tc.desc: 474 * @tc.type: FUNC 475 * @tc.require: 476 * @tc.author: wanyi 477 */ 478 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest012, TestSize.Level0) 479 { 480 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 481 DATA_EMPTY_ASSET, DATA_ASSETS_ASSET_SAME_NAME); 482 std::map<std::string, Assets> expectedList; 483 TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a1); 484 TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a2); 485 TagAsset(AssetOpType::DELETE, AssetStatus::DOWNLOADING, a3); 486 expectedList[FIELD_HOUSE] = { a1 }; 487 expectedList[FIELD_CARS] = { a1, a2, a3 }; 488 ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); 489 ASSERT_TRUE(CheckAssetDownloadList(FIELD_CARS, assetList, expectedList)); 490 } 491 492 /** 493 * @tc.name: AssetCmpTest013 494 * @tc.desc: 495 * @tc.type: FUNC 496 * @tc.require: 497 * @tc.author: wanyi 498 */ 499 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest013, TestSize.Level0) 500 { 501 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 502 DATA_BASELINE, DATA_ASSET_IN_ASSETS); 503 std::map<std::string, Assets> expectedList; 504 TagAsset(AssetOpType::NO_CHANGE, AssetStatus::DOWNLOADING, a1); 505 TagAsset(AssetOpType::NO_CHANGE, AssetStatus::DOWNLOADING, a2); 506 TagAsset(AssetOpType::NO_CHANGE, AssetStatus::DOWNLOADING, a3); 507 TagAsset(AssetOpType::NO_CHANGE, AssetStatus::DOWNLOADING, a4); 508 a2.status = static_cast<uint32_t>(AssetStatus::NORMAL); 509 a3.status = static_cast<uint32_t>(AssetStatus::NORMAL); 510 a4.status = static_cast<uint32_t>(AssetStatus::NORMAL); 511 expectedList[FIELD_CARS] = {a2, a3, a4}; 512 ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); 513 ASSERT_TRUE(CheckAssetDownloadList(FIELD_CARS, assetList, expectedList)); 514 } 515 516 /** 517 * @tc.name: AssetCmpTest014 518 * @tc.desc: 519 * @tc.type: FUNC 520 * @tc.require: 521 * @tc.author: wanyi 522 */ 523 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest014, TestSize.Level0) 524 { 525 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 526 DATA_BASELINE, DATA_NULL_ASSETS); 527 std::map<std::string, Assets> expectedList; 528 TagAsset(AssetOpType::NO_CHANGE, AssetStatus::DOWNLOADING, a1); 529 TagAsset(AssetOpType::INSERT, AssetStatus::DOWNLOADING, a2); 530 TagAsset(AssetOpType::INSERT, AssetStatus::DOWNLOADING, a3); 531 TagAsset(AssetOpType::INSERT, AssetStatus::DOWNLOADING, a4); 532 expectedList[FIELD_HOUSE] = {}; 533 expectedList[FIELD_CARS] = { a2, a3, a4 }; 534 ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); 535 ASSERT_TRUE(CheckAssetDownloadList(FIELD_CARS, assetList, expectedList)); 536 } 537 538 539 /** 540 * @tc.name: AssetCmpTest015 541 * @tc.desc: 542 * @tc.type: FUNC 543 * @tc.require: 544 * @tc.author: wanyi 545 */ 546 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest015, TestSize.Level0) 547 { 548 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord(DATA_ASSET_SAME_NAME_BUT_CHANGE, DATA_BASELINE); 549 std::map<std::string, Assets> expectedList; 550 TagAsset(AssetOpType::UPDATE, AssetStatus::DOWNLOADING, a1Changed); 551 expectedList[FIELD_HOUSE] = { a1Changed }; 552 expectedList[FIELD_CARS] = {a2, a3, a4}; 553 ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); 554 ASSERT_TRUE(CheckAssetDownloadList(FIELD_CARS, assetList, expectedList)); 555 } 556 557 /** 558 * @tc.name: AssetCmpTest016 559 * @tc.desc: 560 * @tc.type: FUNC 561 * @tc.require: 562 * @tc.author: wanyi 563 */ 564 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest016, TestSize.Level0) 565 { 566 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord(DATA_BASELINE, DATA_ASSET_SAME_NAME_BUT_CHANGE); 567 EXPECT_EQ(std::get<Asset>(DATA_BASELINE[FIELD_HOUSE]).flag, static_cast<uint32_t>(AssetOpType::UPDATE)); 568 } 569 570 /** 571 * @tc.name: AssetCmpTest017 572 * @tc.desc: 573 * @tc.type: FUNC 574 * @tc.require: 575 * @tc.author: wanyi 576 */ 577 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest017, TestSize.Level0) 578 { 579 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 580 DATA_BASELINE, DATA_ASSETS_SAME_NAME_PARTIALLY_CHANGED, true); 581 EXPECT_EQ(std::get<Assets>(DATA_BASELINE[FIELD_CARS])[0].flag, static_cast<uint32_t>(AssetOpType::NO_CHANGE)); 582 EXPECT_EQ(std::get<Assets>(DATA_BASELINE[FIELD_CARS])[1].flag, static_cast<uint32_t>(AssetOpType::UPDATE)); 583 EXPECT_EQ(std::get<Assets>(DATA_BASELINE[FIELD_CARS])[2].flag, static_cast<uint32_t>(AssetOpType::NO_CHANGE)); 584 } 585 586 /** 587 * @tc.name: AssetCmpTest018 588 * @tc.desc: 589 * @tc.type: FUNC 590 * @tc.require: 591 * @tc.author: wanyi 592 */ 593 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest018, TestSize.Level0) 594 { 595 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 596 DATA_BASELINE, DATA_EMPTY, true); 597 EXPECT_EQ(std::get<Asset>(DATA_BASELINE[FIELD_HOUSE]).flag, static_cast<uint32_t>(AssetOpType::INSERT)); 598 EXPECT_EQ(std::get<Assets>(DATA_BASELINE[FIELD_CARS])[0].flag, static_cast<uint32_t>(AssetOpType::INSERT)); 599 EXPECT_EQ(std::get<Assets>(DATA_BASELINE[FIELD_CARS])[1].flag, static_cast<uint32_t>(AssetOpType::INSERT)); 600 EXPECT_EQ(std::get<Assets>(DATA_BASELINE[FIELD_CARS])[2].flag, static_cast<uint32_t>(AssetOpType::INSERT)); 601 } 602 603 /** 604 * @tc.name: AssetCmpTest019 605 * @tc.desc: 606 * @tc.type: FUNC 607 * @tc.require: 608 * @tc.author: wanyi 609 */ 610 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest019, TestSize.Level0) 611 { 612 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 613 DATA_EMPTY, DATA_BASELINE, true); 614 EXPECT_EQ(std::get<Assets>(DATA_EMPTY[FIELD_CARS])[0].flag, static_cast<uint32_t>(AssetOpType::DELETE)); 615 EXPECT_EQ(std::get<Assets>(DATA_EMPTY[FIELD_CARS])[1].flag, static_cast<uint32_t>(AssetOpType::DELETE)); 616 EXPECT_EQ(std::get<Assets>(DATA_EMPTY[FIELD_CARS])[2].flag, static_cast<uint32_t>(AssetOpType::DELETE)); 617 } 618 619 /** 620 * @tc.name: AssetCmpTest020 621 * @tc.desc: 622 * @tc.type: FUNC 623 * @tc.require: 624 * @tc.author: wanyi 625 */ 626 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest020, TestSize.Level0) 627 { 628 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 629 DATA_ALL_NULL_ASSETS, DATA_BASELINE, true); 630 EXPECT_EQ(std::get<Asset>(DATA_BASELINE[FIELD_HOUSE]).flag, static_cast<uint32_t>(AssetOpType::DELETE)); 631 EXPECT_EQ(std::get<Assets>(DATA_ALL_NULL_ASSETS[FIELD_CARS])[0].flag, 632 static_cast<uint32_t>(AssetOpType::DELETE)); 633 EXPECT_EQ(std::get<Assets>(DATA_ALL_NULL_ASSETS[FIELD_CARS])[1].flag, 634 static_cast<uint32_t>(AssetOpType::DELETE)); 635 EXPECT_EQ(std::get<Assets>(DATA_ALL_NULL_ASSETS[FIELD_CARS])[2].flag, 636 static_cast<uint32_t>(AssetOpType::DELETE)); 637 638 std::map<std::string, Assets> expectedList; 639 TagAsset(AssetOpType::DELETE, AssetStatus::NORMAL, a1); 640 TagAsset(AssetOpType::DELETE, AssetStatus::NORMAL, a2); 641 TagAsset(AssetOpType::DELETE, AssetStatus::NORMAL, a3); 642 TagAsset(AssetOpType::DELETE, AssetStatus::NORMAL, a4); 643 expectedList[FIELD_HOUSE] = { a1 }; 644 expectedList[FIELD_CARS] = { a2, a3, a4 }; 645 ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); 646 ASSERT_TRUE(CheckAssetDownloadList(FIELD_CARS, assetList, expectedList)); 647 } 648 649 /** 650 * @tc.name: AssetCmpTest021 651 * @tc.desc: 652 * @tc.type: FUNC 653 * @tc.require: 654 * @tc.author: wanyi 655 */ 656 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest021, TestSize.Level0) 657 { 658 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 659 DATA_ALL_NULL_ASSETS, DATA_ALL_NULL_ASSETS, true); 660 ASSERT_TRUE(DATA_ALL_NULL_ASSETS[FIELD_HOUSE].index() == TYPE_INDEX<Nil>); 661 ASSERT_TRUE(DATA_ALL_NULL_ASSETS[FIELD_CARS].index() == TYPE_INDEX<Nil>); 662 663 std::map<std::string, Assets> expectedList; 664 expectedList[FIELD_HOUSE] = {}; 665 expectedList[FIELD_CARS] = {}; 666 ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); 667 ASSERT_TRUE(CheckAssetDownloadList(FIELD_CARS, assetList, expectedList)); 668 } 669 670 /** 671 * @tc.name: AssetCmpTest022 672 * @tc.desc: 673 * @tc.type: FUNC 674 * @tc.require: 675 * @tc.author: wanyi 676 */ 677 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest022, TestSize.Level0) 678 { 679 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 680 DATA_BASELINE, DATA_ALL_NULL_ASSETS, true); 681 EXPECT_EQ(std::get<Asset>(DATA_BASELINE[FIELD_HOUSE]).flag, static_cast<uint32_t>(AssetOpType::INSERT)); 682 EXPECT_EQ(std::get<Assets>(DATA_BASELINE[FIELD_CARS])[0].flag, static_cast<uint32_t>(AssetOpType::INSERT)); 683 EXPECT_EQ(std::get<Assets>(DATA_BASELINE[FIELD_CARS])[1].flag, static_cast<uint32_t>(AssetOpType::INSERT)); 684 EXPECT_EQ(std::get<Assets>(DATA_BASELINE[FIELD_CARS])[2].flag, static_cast<uint32_t>(AssetOpType::INSERT)); 685 686 std::map<std::string, Assets> expectedList; 687 TagAsset(AssetOpType::INSERT, AssetStatus::NORMAL, a1); 688 TagAsset(AssetOpType::INSERT, AssetStatus::NORMAL, a2); 689 TagAsset(AssetOpType::INSERT, AssetStatus::NORMAL, a3); 690 TagAsset(AssetOpType::INSERT, AssetStatus::NORMAL, a4); 691 expectedList[FIELD_HOUSE] = { a1 }; 692 expectedList[FIELD_CARS] = { a2, a3, a4 }; 693 ASSERT_TRUE(CheckAssetDownloadList(FIELD_HOUSE, assetList, expectedList)); 694 ASSERT_TRUE(CheckAssetDownloadList(FIELD_CARS, assetList, expectedList)); 695 } 696 697 /** 698 * @tc.name: AssetCmpTest023 699 * @tc.desc: 700 * @tc.type: FUNC 701 * @tc.require: 702 * @tc.author: wanyi 703 */ 704 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest023, TestSize.Level0) 705 { 706 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 707 DATA_ASSET_SAME_NAME_BUT_CHANGE, DATA_BASELINE, true); 708 EXPECT_EQ(std::get<Asset>(DATA_ASSET_SAME_NAME_BUT_CHANGE[FIELD_HOUSE]).flag, 709 static_cast<uint32_t>(AssetOpType::UPDATE)); 710 EXPECT_EQ(std::get<Assets>(DATA_ASSET_SAME_NAME_BUT_CHANGE[FIELD_CARS])[0].flag, 711 static_cast<uint32_t>(AssetOpType::NO_CHANGE)); 712 EXPECT_EQ(std::get<Assets>(DATA_ASSET_SAME_NAME_BUT_CHANGE[FIELD_CARS])[1].flag, 713 static_cast<uint32_t>(AssetOpType::NO_CHANGE)); 714 EXPECT_EQ(std::get<Assets>(DATA_ASSET_SAME_NAME_BUT_CHANGE[FIELD_CARS])[2].flag, 715 static_cast<uint32_t>(AssetOpType::NO_CHANGE)); 716 } 717 718 /** 719 * @tc.name: AssetCmpTest024 720 * @tc.desc: 721 * @tc.type: FUNC 722 * @tc.require: 723 * @tc.author: wanyi 724 */ 725 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest024, TestSize.Level0) 726 { 727 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 728 DATA_ASSETS_DIFFERENT_CHANGED_FIELD, DATA_BASELINE, true); 729 EXPECT_EQ(std::get<Asset>(DATA_ASSETS_DIFFERENT_CHANGED_FIELD[FIELD_HOUSE]).flag, 730 static_cast<uint32_t>(AssetOpType::NO_CHANGE)); 731 EXPECT_EQ(std::get<Assets>(DATA_ASSETS_DIFFERENT_CHANGED_FIELD[FIELD_CARS])[0].flag, 732 static_cast<uint32_t>(AssetOpType::NO_CHANGE)); 733 EXPECT_EQ(std::get<Assets>(DATA_ASSETS_DIFFERENT_CHANGED_FIELD[FIELD_CARS])[1].flag, 734 static_cast<uint32_t>(AssetOpType::UPDATE)); 735 EXPECT_EQ(std::get<Assets>(DATA_ASSETS_DIFFERENT_CHANGED_FIELD[FIELD_CARS])[2].flag, 736 static_cast<uint32_t>(AssetOpType::INSERT)); 737 EXPECT_EQ(std::get<Assets>(DATA_ASSETS_DIFFERENT_CHANGED_FIELD[FIELD_CARS])[3].flag, 738 static_cast<uint32_t>(AssetOpType::DELETE)); 739 } 740 741 /** 742 * @tc.name: AssetCmpTest025 743 * @tc.desc: Cloud device contain a record without assets, local device insert an assets and begin to sync. 744 * CloudAsset will be a record without assets. Local data will be a record with assets. 745 * @tc.type: FUNC 746 * @tc.require: 747 * @tc.author: wanyi 748 */ 749 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest025, TestSize.Level0) 750 { 751 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord(DATA_BASELINE, DATA_NULL_ASSETS, true); 752 EXPECT_EQ(std::get<Asset>(DATA_BASELINE[FIELD_HOUSE]).flag, static_cast<uint32_t>(AssetOpType::NO_CHANGE)); 753 EXPECT_EQ(std::get<Assets>(DATA_BASELINE[FIELD_CARS])[0].flag, static_cast<uint32_t>(AssetOpType::INSERT)); 754 EXPECT_EQ(std::get<Assets>(DATA_BASELINE[FIELD_CARS])[1].flag, static_cast<uint32_t>(AssetOpType::INSERT)); 755 EXPECT_EQ(std::get<Assets>(DATA_BASELINE[FIELD_CARS])[2].flag, static_cast<uint32_t>(AssetOpType::INSERT)); 756 } 757 758 /** 759 * @tc.name: AssetCmpTest026 760 * @tc.desc: Cloud device contain a record without assets, local device insert an assets and begin to sync. 761 * CloudAsset will be a record without assets. Local data will be a record with assets. 762 * In this case, record do not contain certain asset column 763 * @tc.type: FUNC 764 * @tc.require: 765 * @tc.author: wanyi 766 */ 767 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest026, TestSize.Level0) 768 { 769 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord(DATA_BASELINE, DATA_EMPTY_ASSETS, true); 770 EXPECT_EQ(std::get<Asset>(DATA_BASELINE[FIELD_HOUSE]).flag, static_cast<uint32_t>(AssetOpType::NO_CHANGE)); 771 EXPECT_EQ(std::get<Assets>(DATA_BASELINE[FIELD_CARS])[0].flag, static_cast<uint32_t>(AssetOpType::INSERT)); 772 EXPECT_EQ(std::get<Assets>(DATA_BASELINE[FIELD_CARS])[1].flag, static_cast<uint32_t>(AssetOpType::INSERT)); 773 EXPECT_EQ(std::get<Assets>(DATA_BASELINE[FIELD_CARS])[2].flag, static_cast<uint32_t>(AssetOpType::INSERT)); 774 } 775 776 /** 777 * @tc.name: AssetCmpTest027 778 * @tc.desc: 779 * @tc.type: FUNC 780 * @tc.require: 781 * @tc.author: wanyi 782 */ 783 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest027, TestSize.Level0) 784 { 785 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 786 DATA_UPDATE_DELTE_NOCHANGE_INSERT, DATA_BASELINE, false); 787 EXPECT_EQ(std::get<Assets>(DATA_UPDATE_DELTE_NOCHANGE_INSERT[FIELD_CARS])[0].flag, 788 static_cast<uint32_t>(AssetOpType::UPDATE)); 789 EXPECT_EQ(std::get<Assets>(DATA_UPDATE_DELTE_NOCHANGE_INSERT[FIELD_CARS])[1].flag, 790 static_cast<uint32_t>(AssetOpType::NO_CHANGE)); 791 EXPECT_EQ(std::get<Assets>(DATA_UPDATE_DELTE_NOCHANGE_INSERT[FIELD_CARS])[2].flag, 792 static_cast<uint32_t>(AssetOpType::INSERT)); 793 EXPECT_EQ(std::get<Assets>(DATA_UPDATE_DELTE_NOCHANGE_INSERT[FIELD_CARS])[3].flag, 794 static_cast<uint32_t>(AssetOpType::DELETE)); 795 } 796 797 /** 798 * @tc.name: AssetCmpTest028 799 * @tc.desc: Two same name asset appears in the assets field, this situation is not allowed 800 * @tc.type: FUNC 801 * @tc.require: 802 * @tc.author: wanyi 803 */ 804 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest028, TestSize.Level0) 805 { 806 auto assetList = g_cloudSyncer->TestTagAssetsInSingleRecord( 807 DATA_ALL_NULL_ASSETS, DATA_BASELINE, true); 808 EXPECT_EQ(std::get<Assets>(DATA_ALL_NULL_ASSETS[FIELD_CARS])[0].flag, 809 static_cast<uint32_t>(AssetOpType::DELETE)); 810 EXPECT_EQ(std::get<Assets>(DATA_ALL_NULL_ASSETS[FIELD_CARS])[1].flag, 811 static_cast<uint32_t>(AssetOpType::DELETE)); 812 EXPECT_EQ(std::get<Assets>(DATA_ALL_NULL_ASSETS[FIELD_CARS])[2].flag, 813 static_cast<uint32_t>(AssetOpType::DELETE)); 814 } 815 816 /** 817 * @tc.name: AssetCmpTest029 818 * @tc.desc: Two same name asset appears in the assets field, this situation is not allowed 819 * @tc.type: FUNC 820 * @tc.require: 821 * @tc.author: wanyi 822 */ 823 HWTEST_F(DistributedDBCloudAssetCompareTest, AssetCmpTest029, TestSize.Level0) 824 { 825 Field field1 = { FIELD_HOUSE, TYPE_INDEX<Asset> }; 826 Field field2 = { FIELD_CARS, TYPE_INDEX<Assets> }; 827 std::vector<Field> assetFields = { field1, field2 }; 828 ASSERT_TRUE(g_cloudSyncer->TestIsDataContainDuplicateAsset(assetFields, DATA_SAME_NAME_ASSETS)); 829 ASSERT_TRUE(g_cloudSyncer->TestIsDataContainDuplicateAsset(assetFields, DATA_BASELINE) == false); 830 } 831 }