src/chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk.h"
   6
   7 #include "base/files/scoped_temp_dir.h"
   8 #include "base/strings/string_number_conversions.h"
   9 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
  10 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_test_util.h"
  11 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_util.h"
  12 #include "chrome/browser/sync_file_system/drive_backend/leveldb_wrapper.h"
  13 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
  16 #include "third_party/leveldatabase/src/include/leveldb/db.h"
  17 #include "third_party/leveldatabase/src/include/leveldb/env.h"
  18 #include "third_party/leveldatabase/src/include/leveldb/status.h"
  19
  20 namespace sync_file_system {
  21 namespace drive_backend {
  22
  23 namespace {
  24
  25 const int64 kSyncRootTrackerID = 1;
  26 const int64 kAppRootTrackerID = 2;
  27 const int64 kFileTrackerID = 3;
  28 const int64 kPlaceholderTrackerID = 4;
  29
  30 }  // namespace
  31
  32 class MetadataDatabaseIndexOnDiskTest : public testing::Test {
  33  public:
  34   virtual ~MetadataDatabaseIndexOnDiskTest() {}
  35
  36   virtual void SetUp() OVERRIDE {
  37     ASSERT_TRUE(database_dir_.CreateUniqueTempDir());
  38     in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
  39     db_ = InitializeLevelDB();
  40     index_ = MetadataDatabaseIndexOnDisk::Create(db_.get());
  41   }
  42
  43   virtual void TearDown() OVERRIDE {
  44     index_.reset();
  45     db_.reset();
  46     in_memory_env_.reset();
  47   }
  48
  49   void CreateTestDatabase(bool build_index, LevelDBWrapper* db) {
  50     if (!db) {
  51       DCHECK(index());
  52       db = index()->GetDBForTesting();
  53     }
  54     DCHECK(db);
  55
  56     scoped_ptr<FileMetadata> sync_root_metadata =
  57         test_util::CreateFolderMetadata("sync_root_folder_id",
  58                                         "Chrome Syncable FileSystem");
  59     scoped_ptr<FileTracker> sync_root_tracker =
  60         test_util::CreateTracker(*sync_root_metadata, kSyncRootTrackerID, NULL);
  61
  62     scoped_ptr<FileMetadata> app_root_metadata =
  63         test_util::CreateFolderMetadata("app_root_folder_id", "app_title");
  64     scoped_ptr<FileTracker> app_root_tracker =
  65         test_util::CreateTracker(*app_root_metadata, kAppRootTrackerID,
  66                                  sync_root_tracker.get());
  67     app_root_tracker->set_app_id("app_id");
  68     app_root_tracker->set_tracker_kind(TRACKER_KIND_APP_ROOT);
  69
  70     scoped_ptr<FileMetadata> file_metadata =
  71         test_util::CreateFileMetadata("file_id", "file", "file_md5");
  72     scoped_ptr<FileTracker> file_tracker =
  73         test_util::CreateTracker(*file_metadata,
  74                                  kFileTrackerID,
  75                                  app_root_tracker.get());
  76
  77     scoped_ptr<FileTracker> placeholder_tracker =
  78         test_util::CreatePlaceholderTracker("unsynced_file_id",
  79                                             kPlaceholderTrackerID,
  80                                             app_root_tracker.get());
  81
  82     scoped_ptr<ServiceMetadata> service_metadata =
  83         InitializeServiceMetadata(db);
  84     service_metadata->set_sync_root_tracker_id(kSyncRootTrackerID);
  85     PutServiceMetadataToDB(*service_metadata, db);
  86
  87     if (build_index) {
  88       DCHECK(index());
  89
  90       index()->StoreFileMetadata(sync_root_metadata.Pass());
  91       index()->StoreFileTracker(sync_root_tracker.Pass());
  92       index()->StoreFileMetadata(app_root_metadata.Pass());
  93       index()->StoreFileTracker(app_root_tracker.Pass());
  94       index()->StoreFileMetadata(file_metadata.Pass());
  95       index()->StoreFileTracker(file_tracker.Pass());
  96       index()->StoreFileTracker(placeholder_tracker.Pass());
  97     } else {
  98       PutFileMetadataToDB(*sync_root_metadata, db);
  99       PutFileTrackerToDB(*sync_root_tracker, db);
 100       PutFileMetadataToDB(*app_root_metadata, db);
 101       PutFileTrackerToDB(*app_root_tracker, db);
 102       PutFileMetadataToDB(*file_metadata, db);
 103       PutFileTrackerToDB(*file_tracker, db);
 104       PutFileTrackerToDB(*placeholder_tracker, db);
 105     }
 106
 107     ASSERT_TRUE(db->Commit().ok());
 108   }
 109
 110   MetadataDatabaseIndexOnDisk* index() { return index_.get(); }
 111
 112   void WriteToDB() {
 113     ASSERT_TRUE(db_->Commit().ok());
 114   }
 115
 116   scoped_ptr<LevelDBWrapper> InitializeLevelDB() {
 117     leveldb::DB* db = NULL;
 118     leveldb::Options options;
 119     options.create_if_missing = true;
 120     options.max_open_files = 0;  // Use minimum.
 121     options.env = in_memory_env_.get();
 122     leveldb::Status status =
 123         leveldb::DB::Open(options, database_dir_.path().AsUTF8Unsafe(), &db);
 124     EXPECT_TRUE(status.ok());
 125     return make_scoped_ptr(new LevelDBWrapper(make_scoped_ptr(db)));
 126   }
 127
 128  private:
 129   scoped_ptr<MetadataDatabaseIndexOnDisk> index_;
 130
 131   base::ScopedTempDir database_dir_;
 132   scoped_ptr<leveldb::Env> in_memory_env_;
 133   scoped_ptr<LevelDBWrapper> db_;
 134 };
 135
 136 TEST_F(MetadataDatabaseIndexOnDiskTest, GetEntryTest) {
 137   CreateTestDatabase(false, NULL);
 138
 139   FileTracker tracker;
 140   EXPECT_FALSE(index()->GetFileTracker(kInvalidTrackerID, NULL));
 141   ASSERT_TRUE(index()->GetFileTracker(kFileTrackerID, &tracker));
 142   EXPECT_EQ(kFileTrackerID, tracker.tracker_id());
 143   EXPECT_EQ("file_id", tracker.file_id());
 144
 145   FileMetadata metadata;
 146   EXPECT_FALSE(index()->GetFileMetadata(std::string(), NULL));
 147   ASSERT_TRUE(index()->GetFileMetadata("file_id", &metadata));
 148   EXPECT_EQ("file_id", metadata.file_id());
 149 }
 150
 151 TEST_F(MetadataDatabaseIndexOnDiskTest, SetEntryTest) {
 152   CreateTestDatabase(false, NULL);
 153
 154   const int64 tracker_id = 10;
 155   scoped_ptr<FileMetadata> metadata =
 156       test_util::CreateFileMetadata("test_file_id", "test_title", "test_md5");
 157   FileTracker root_tracker;
 158   EXPECT_TRUE(index()->GetFileTracker(kSyncRootTrackerID, &root_tracker));
 159   scoped_ptr<FileTracker> tracker =
 160       test_util::CreateTracker(*metadata, tracker_id, &root_tracker);
 161
 162   index()->StoreFileMetadata(metadata.Pass());
 163   index()->StoreFileTracker(tracker.Pass());
 164
 165   EXPECT_TRUE(index()->GetFileMetadata("test_file_id", NULL));
 166   EXPECT_TRUE(index()->GetFileTracker(tracker_id, NULL));
 167
 168   WriteToDB();
 169
 170   metadata.reset(new FileMetadata);
 171   ASSERT_TRUE(index()->GetFileMetadata("test_file_id", metadata.get()));
 172   EXPECT_TRUE(metadata->has_details());
 173   EXPECT_EQ("test_title", metadata->details().title());
 174
 175   tracker.reset(new FileTracker);
 176   ASSERT_TRUE(index()->GetFileTracker(tracker_id, tracker.get()));
 177   EXPECT_EQ("test_file_id", tracker->file_id());
 178
 179   // Test if removers work.
 180   index()->RemoveFileMetadata("test_file_id");
 181   index()->RemoveFileTracker(tracker_id);
 182
 183   EXPECT_FALSE(index()->GetFileMetadata("test_file_id", NULL));
 184   EXPECT_FALSE(index()->GetFileTracker(tracker_id, NULL));
 185
 186   WriteToDB();
 187
 188   EXPECT_FALSE(index()->GetFileMetadata("test_file_id", NULL));
 189   EXPECT_FALSE(index()->GetFileTracker(tracker_id, NULL));
 190 }
 191
 192 TEST_F(MetadataDatabaseIndexOnDiskTest, RemoveUnreachableItemsTest) {
 193   scoped_ptr<LevelDBWrapper> db = InitializeLevelDB();
 194   CreateTestDatabase(false, db.get());
 195
 196   const int kOrphanedFileTrackerID = 13;
 197   scoped_ptr<FileMetadata> orphaned_metadata =
 198       test_util::CreateFileMetadata("orphaned_id", "orphaned", "md5");
 199   scoped_ptr<FileTracker> orphaned_tracker =
 200       test_util::CreateTracker(*orphaned_metadata,
 201                                kOrphanedFileTrackerID,
 202                                NULL);
 203
 204   PutFileMetadataToDB(*orphaned_metadata, db.get());
 205   PutFileTrackerToDB(*orphaned_tracker, db.get());
 206   EXPECT_TRUE(db->Commit().ok());
 207
 208   const std::string key =
 209       kFileTrackerKeyPrefix + base::Int64ToString(kOrphanedFileTrackerID);
 210   std::string value;
 211   EXPECT_TRUE(db->Get(key, &value).ok());
 212
 213   // RemoveUnreachableItems() is expected to run on index creation.
 214   scoped_ptr<MetadataDatabaseIndexOnDisk> index_on_disk =
 215       MetadataDatabaseIndexOnDisk::Create(db.get());
 216   EXPECT_TRUE(db->Commit().ok());
 217
 218   EXPECT_TRUE(db->Get(key, &value).IsNotFound());
 219   EXPECT_FALSE(index_on_disk->GetFileTracker(kOrphanedFileTrackerID, NULL));
 220
 221   EXPECT_TRUE(index_on_disk->GetFileTracker(kSyncRootTrackerID, NULL));
 222   EXPECT_TRUE(index_on_disk->GetFileTracker(kAppRootTrackerID, NULL));
 223   EXPECT_TRUE(index_on_disk->GetFileTracker(kFileTrackerID, NULL));
 224 }
 225
 226
 227 TEST_F(MetadataDatabaseIndexOnDiskTest, BuildIndexTest) {
 228   CreateTestDatabase(false, NULL);
 229
 230   TrackerIDSet tracker_ids;
 231   // Before building indexes, no references exist.
 232   EXPECT_EQ(kInvalidTrackerID, index()->GetAppRootTracker("app_id"));
 233   tracker_ids = index()->GetFileTrackerIDsByFileID("file_id");
 234   EXPECT_TRUE(tracker_ids.empty());
 235   tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
 236       kAppRootTrackerID, "file");
 237   EXPECT_TRUE(tracker_ids.empty());
 238   EXPECT_EQ(0U, index()->CountDirtyTracker());
 239
 240   EXPECT_EQ(16, index()->BuildTrackerIndexes());
 241   WriteToDB();
 242
 243   // After building indexes, we should have correct indexes.
 244   EXPECT_EQ(kAppRootTrackerID, index()->GetAppRootTracker("app_id"));
 245   tracker_ids = index()->GetFileTrackerIDsByFileID("file_id");
 246   EXPECT_EQ(1U, tracker_ids.size());
 247   EXPECT_EQ(kFileTrackerID, tracker_ids.active_tracker());
 248   tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
 249       kAppRootTrackerID, "file");
 250   EXPECT_EQ(1U, tracker_ids.size());
 251   EXPECT_EQ(kFileTrackerID, tracker_ids.active_tracker());
 252   EXPECT_EQ(1U, index()->CountDirtyTracker());
 253 }
 254
 255 TEST_F(MetadataDatabaseIndexOnDiskTest, BuildAndDeleteIndexTest) {
 256   CreateTestDatabase(false, NULL);
 257   int64 answer = index()->BuildTrackerIndexes();
 258   WriteToDB();
 259   ASSERT_EQ(16, answer);
 260   EXPECT_EQ(answer, index()->DeleteTrackerIndexes());
 261   WriteToDB();
 262   EXPECT_EQ(answer, index()->BuildTrackerIndexes());
 263   WriteToDB();
 264 }
 265
 266 TEST_F(MetadataDatabaseIndexOnDiskTest, AllEntriesTest) {
 267   CreateTestDatabase(true, NULL);
 268
 269   EXPECT_EQ(3U, index()->CountFileMetadata());
 270   std::vector<std::string> file_ids(index()->GetAllMetadataIDs());
 271   ASSERT_EQ(3U, file_ids.size());
 272   std::sort(file_ids.begin(), file_ids.end());
 273   EXPECT_EQ("app_root_folder_id", file_ids[0]);
 274   EXPECT_EQ("file_id", file_ids[1]);
 275   EXPECT_EQ("sync_root_folder_id", file_ids[2]);
 276
 277   EXPECT_EQ(4U, index()->CountFileTracker());
 278   std::vector<int64> tracker_ids = index()->GetAllTrackerIDs();
 279   ASSERT_EQ(4U, tracker_ids.size());
 280   std::sort(tracker_ids.begin(), tracker_ids.end());
 281   EXPECT_EQ(kSyncRootTrackerID, tracker_ids[0]);
 282   EXPECT_EQ(kAppRootTrackerID, tracker_ids[1]);
 283   EXPECT_EQ(kFileTrackerID, tracker_ids[2]);
 284   EXPECT_EQ(kPlaceholderTrackerID, tracker_ids[3]);
 285 }
 286
 287 TEST_F(MetadataDatabaseIndexOnDiskTest, IndexAppRootIDByAppIDTest) {
 288   CreateTestDatabase(true, NULL);
 289
 290   std::vector<std::string> app_ids = index()->GetRegisteredAppIDs();
 291   ASSERT_EQ(1U, app_ids.size());
 292   EXPECT_EQ("app_id", app_ids[0]);
 293
 294   EXPECT_EQ(kInvalidTrackerID, index()->GetAppRootTracker(""));
 295   EXPECT_EQ(kAppRootTrackerID, index()->GetAppRootTracker("app_id"));
 296
 297   const int64 kAppRootTrackerID2 = 12;
 298   FileTracker sync_root_tracker;
 299   index()->GetFileTracker(kSyncRootTrackerID, &sync_root_tracker);
 300   scoped_ptr<FileMetadata> app_root_metadata =
 301       test_util::CreateFolderMetadata("app_root_folder_id_2", "app_title_2");
 302
 303   // Testing AddToAppIDIndex
 304   scoped_ptr<FileTracker> app_root_tracker =
 305       test_util::CreateTracker(*app_root_metadata, kAppRootTrackerID2,
 306                                &sync_root_tracker);
 307   app_root_tracker->set_app_id("app_id_2");
 308   app_root_tracker->set_tracker_kind(TRACKER_KIND_APP_ROOT);
 309
 310   index()->StoreFileTracker(app_root_tracker.Pass());
 311   WriteToDB();
 312   EXPECT_EQ(kAppRootTrackerID, index()->GetAppRootTracker("app_id"));
 313   EXPECT_EQ(kAppRootTrackerID2, index()->GetAppRootTracker("app_id_2"));
 314
 315   // Testing UpdateInAppIDIndex
 316   app_root_tracker = test_util::CreateTracker(*app_root_metadata,
 317                                               kAppRootTrackerID2,
 318                                               &sync_root_tracker);
 319   app_root_tracker->set_app_id("app_id_3");
 320   app_root_tracker->set_active(false);
 321
 322   index()->StoreFileTracker(app_root_tracker.Pass());
 323   WriteToDB();
 324   EXPECT_EQ(kAppRootTrackerID, index()->GetAppRootTracker("app_id"));
 325   EXPECT_EQ(kInvalidTrackerID, index()->GetAppRootTracker("app_id_2"));
 326   EXPECT_EQ(kInvalidTrackerID, index()->GetAppRootTracker("app_id_3"));
 327
 328   app_root_tracker = test_util::CreateTracker(*app_root_metadata,
 329                                               kAppRootTrackerID2,
 330                                               &sync_root_tracker);
 331   app_root_tracker->set_app_id("app_id_3");
 332   app_root_tracker->set_tracker_kind(TRACKER_KIND_APP_ROOT);
 333
 334   index()->StoreFileTracker(app_root_tracker.Pass());
 335   WriteToDB();
 336   EXPECT_EQ(kAppRootTrackerID, index()->GetAppRootTracker("app_id"));
 337   EXPECT_EQ(kInvalidTrackerID, index()->GetAppRootTracker("app_id_2"));
 338   EXPECT_EQ(kAppRootTrackerID2, index()->GetAppRootTracker("app_id_3"));
 339
 340   // Testing RemoveFromAppIDIndex
 341   index()->RemoveFileTracker(kAppRootTrackerID2);
 342   WriteToDB();
 343   EXPECT_EQ(kAppRootTrackerID, index()->GetAppRootTracker("app_id"));
 344   EXPECT_EQ(kInvalidTrackerID, index()->GetAppRootTracker("app_id_3"));
 345 }
 346
 347 TEST_F(MetadataDatabaseIndexOnDiskTest, TrackerIDSetByFileIDTest) {
 348   CreateTestDatabase(true, NULL);
 349
 350   FileTracker app_root_tracker;
 351   EXPECT_TRUE(index()->GetFileTracker(kAppRootTrackerID, &app_root_tracker));
 352   FileMetadata metadata;
 353   EXPECT_TRUE(index()->GetFileMetadata("file_id", &metadata));
 354
 355   // Testing GetFileTrackerIDsByFileID
 356   TrackerIDSet tracker_ids = index()->GetFileTrackerIDsByFileID("file_id");
 357   EXPECT_EQ(1U, tracker_ids.size());
 358   EXPECT_EQ(kFileTrackerID, tracker_ids.active_tracker());
 359
 360   const int64 tracker_id = 21;
 361   // Testing AddToFileIDIndexes
 362   scoped_ptr<FileTracker> file_tracker =
 363       test_util::CreateTracker(metadata, tracker_id, &app_root_tracker);
 364
 365   index()->StoreFileTracker(file_tracker.Pass());
 366   WriteToDB();
 367   tracker_ids = index()->GetFileTrackerIDsByFileID("file_id");
 368   EXPECT_EQ(2U, tracker_ids.size());
 369   EXPECT_EQ(tracker_id, tracker_ids.active_tracker());
 370
 371   std::string multi_file_id = index()->PickMultiTrackerFileID();
 372   EXPECT_EQ("file_id", multi_file_id);
 373
 374   // Testing UpdateInFileIDIndexes
 375   file_tracker =
 376       test_util::CreateTracker(metadata, tracker_id, &app_root_tracker);
 377   file_tracker->set_active(false);
 378
 379   index()->StoreFileTracker(file_tracker.Pass());
 380   WriteToDB();
 381   tracker_ids = index()->GetFileTrackerIDsByFileID("file_id");
 382   EXPECT_EQ(2U, tracker_ids.size());
 383   EXPECT_EQ(kInvalidTrackerID, tracker_ids.active_tracker());
 384
 385   multi_file_id = index()->PickMultiTrackerFileID();
 386   EXPECT_EQ("file_id", multi_file_id);
 387
 388   file_tracker =
 389       test_util::CreateTracker(metadata, tracker_id, &app_root_tracker);
 390
 391   index()->StoreFileTracker(file_tracker.Pass());
 392   WriteToDB();
 393   tracker_ids = index()->GetFileTrackerIDsByFileID("file_id");
 394   EXPECT_EQ(2U, tracker_ids.size());
 395   EXPECT_EQ(tracker_id, tracker_ids.active_tracker());
 396
 397   multi_file_id = index()->PickMultiTrackerFileID();
 398   EXPECT_EQ("file_id", multi_file_id);
 399
 400   // Testing RemoveFromFileIDIndexes
 401   index()->RemoveFileTracker(tracker_id);
 402   WriteToDB();
 403   tracker_ids = index()->GetFileTrackerIDsByFileID("file_id");
 404   EXPECT_EQ(1U, tracker_ids.size());
 405   EXPECT_EQ(kInvalidTrackerID, tracker_ids.active_tracker());
 406
 407   multi_file_id = index()->PickMultiTrackerFileID();
 408   EXPECT_TRUE(multi_file_id.empty()) << multi_file_id;
 409 }
 410
 411 TEST_F(MetadataDatabaseIndexOnDiskTest, TrackerIDSetByParentIDAndTitleTest) {
 412   CreateTestDatabase(true, NULL);
 413
 414   FileTracker app_root_tracker;
 415   EXPECT_TRUE(index()->GetFileTracker(kAppRootTrackerID, &app_root_tracker));
 416   FileMetadata metadata;
 417   EXPECT_TRUE(index()->GetFileMetadata("file_id", &metadata));
 418
 419   // Testing GetFileTrackerIDsByFileID
 420   TrackerIDSet tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
 421       kAppRootTrackerID, "file");
 422   EXPECT_EQ(1U, tracker_ids.size());
 423   EXPECT_EQ(kFileTrackerID, tracker_ids.active_tracker());
 424
 425   tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
 426       kAppRootTrackerID, "file2");
 427   EXPECT_TRUE(tracker_ids.empty());
 428
 429   const int64 tracker_id = 72;
 430   // Testing AddToFileIDIndexes
 431   scoped_ptr<FileTracker> file_tracker =
 432       test_util::CreateTracker(metadata, tracker_id, &app_root_tracker);
 433
 434   index()->StoreFileTracker(file_tracker.Pass());
 435   WriteToDB();
 436   tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
 437       kAppRootTrackerID, "file");
 438   EXPECT_EQ(2U, tracker_ids.size());
 439   EXPECT_EQ(tracker_id, tracker_ids.active_tracker());
 440
 441   ParentIDAndTitle multi_backing = index()->PickMultiBackingFilePath();
 442   EXPECT_EQ(kAppRootTrackerID, multi_backing.parent_id);
 443   EXPECT_EQ("file", multi_backing.title);
 444
 445   // Testing UpdateInFileIDIndexes
 446   file_tracker =
 447       test_util::CreateTracker(metadata, tracker_id, &app_root_tracker);
 448   file_tracker->set_active(false);
 449
 450   index()->StoreFileTracker(file_tracker.Pass());
 451   WriteToDB();
 452   tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
 453       kAppRootTrackerID, "file");
 454   EXPECT_EQ(2U, tracker_ids.size());
 455   EXPECT_EQ(kInvalidTrackerID, tracker_ids.active_tracker());
 456
 457   multi_backing = index()->PickMultiBackingFilePath();
 458   EXPECT_EQ(kAppRootTrackerID, multi_backing.parent_id);
 459   EXPECT_EQ("file", multi_backing.title);
 460
 461   file_tracker =
 462       test_util::CreateTracker(metadata, tracker_id, &app_root_tracker);
 463
 464   index()->StoreFileTracker(file_tracker.Pass());
 465   WriteToDB();
 466   tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
 467       kAppRootTrackerID, "file");
 468   EXPECT_EQ(2U, tracker_ids.size());
 469   EXPECT_EQ(tracker_id, tracker_ids.active_tracker());
 470
 471   multi_backing = index()->PickMultiBackingFilePath();
 472   EXPECT_EQ(kAppRootTrackerID, multi_backing.parent_id);
 473   EXPECT_EQ("file", multi_backing.title);
 474
 475   // Testing RemoveFromFileIDIndexes
 476   index()->RemoveFileTracker(tracker_id);
 477   WriteToDB();
 478   tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
 479       kAppRootTrackerID, "file");
 480   EXPECT_EQ(1U, tracker_ids.size());
 481   EXPECT_EQ(kInvalidTrackerID, tracker_ids.active_tracker());
 482
 483   multi_backing = index()->PickMultiBackingFilePath();
 484   EXPECT_EQ(kInvalidTrackerID, multi_backing.parent_id);
 485   EXPECT_TRUE(multi_backing.title.empty()) << multi_backing.title;
 486 }
 487
 488 TEST_F(MetadataDatabaseIndexOnDiskTest,
 489        TrackerIDSetByParentIDAndTitleTest_EmptyTitle) {
 490   CreateTestDatabase(true, NULL);
 491
 492   const int64 kFolderTrackerID = 23;
 493   const int64 kNewFileTrackerID = 42;
 494   {
 495     FileTracker app_root_tracker;
 496     EXPECT_TRUE(index()->GetFileTracker(kAppRootTrackerID, &app_root_tracker));
 497     scoped_ptr<FileMetadata> folder_metadata =
 498         test_util::CreateFolderMetadata("folder_id", "folder_name");
 499     scoped_ptr<FileTracker> folder_tracker =
 500         test_util::CreateTracker(*folder_metadata, kFolderTrackerID,
 501                                  &app_root_tracker);
 502     index()->StoreFileMetadata(folder_metadata.Pass());
 503     index()->StoreFileTracker(folder_tracker.Pass());
 504     WriteToDB();
 505   }
 506
 507   FileTracker folder_tracker;
 508   EXPECT_TRUE(index()->GetFileTracker(kFolderTrackerID, &folder_tracker));
 509   scoped_ptr<FileMetadata> metadata =
 510       test_util::CreateFileMetadata("file_id2", std::string(), "md5_2");
 511
 512   // Testing GetFileTrackerIDsByFileID
 513   TrackerIDSet tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
 514       kFolderTrackerID, std::string());
 515   EXPECT_TRUE(tracker_ids.empty());
 516
 517   // Testing AddToFileIDIndexes
 518   scoped_ptr<FileTracker> file_tracker =
 519       test_util::CreateTracker(*metadata, kNewFileTrackerID, &folder_tracker);
 520
 521   index()->StoreFileTracker(file_tracker.Pass());
 522   WriteToDB();
 523   tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
 524       kFolderTrackerID, std::string());
 525   EXPECT_EQ(1U, tracker_ids.size());
 526   EXPECT_EQ(kNewFileTrackerID, tracker_ids.active_tracker());
 527
 528   ParentIDAndTitle multi_backing = index()->PickMultiBackingFilePath();
 529   EXPECT_EQ(kInvalidTrackerID, multi_backing.parent_id);
 530
 531   // Testing UpdateInFileIDIndexes
 532   file_tracker =
 533       test_util::CreateTracker(*metadata, kNewFileTrackerID, &folder_tracker);
 534
 535   index()->StoreFileTracker(file_tracker.Pass());
 536   WriteToDB();
 537   tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
 538       kFolderTrackerID, std::string());
 539   EXPECT_EQ(1U, tracker_ids.size());
 540   EXPECT_EQ(kNewFileTrackerID, tracker_ids.active_tracker());
 541
 542   multi_backing = index()->PickMultiBackingFilePath();
 543   EXPECT_EQ(kInvalidTrackerID, multi_backing.parent_id);
 544 }
 545
 546 TEST_F(MetadataDatabaseIndexOnDiskTest, TrackerIDSetDetailsTest) {
 547   CreateTestDatabase(true, NULL);
 548
 549   FileTracker app_root;
 550   EXPECT_TRUE(index()->GetFileTracker(kAppRootTrackerID, &app_root));
 551
 552   const int64 kFileTrackerID2 = 123;
 553   const int64 kFileTrackerID3 = 124;
 554   scoped_ptr<FileMetadata> file_metadata =
 555       test_util::CreateFileMetadata("file_id2", "file_2", "file_md5_2");
 556   scoped_ptr<FileTracker> file_tracker =
 557       test_util::CreateTracker(*file_metadata, kFileTrackerID2, &app_root);
 558   file_tracker->set_active(false);
 559   scoped_ptr<FileTracker> file_tracker2 =
 560       test_util::CreateTracker(*file_metadata, kFileTrackerID3, &app_root);
 561   file_tracker2->set_active(false);
 562
 563   // Add 2 trackers related to one file metadata.
 564   index()->StoreFileMetadata(file_metadata.Pass());
 565   index()->StoreFileTracker(file_tracker.Pass());
 566   index()->StoreFileTracker(file_tracker2.Pass());
 567
 568   TrackerIDSet idset = index()->GetFileTrackerIDsByFileID("file_id2");
 569   EXPECT_EQ(2U, idset.size());
 570   EXPECT_FALSE(idset.has_active());
 571
 572   // Activate one file tracker.
 573   file_tracker.reset(new FileTracker);
 574   index()->GetFileTracker(kFileTrackerID2, file_tracker.get());
 575   file_tracker->set_active(true);
 576   index()->StoreFileTracker(file_tracker.Pass());
 577
 578   idset = index()->GetFileTrackerIDsByFileID("file_id2");
 579   EXPECT_EQ(2U, idset.size());
 580   EXPECT_TRUE(idset.has_active());
 581   EXPECT_EQ(kFileTrackerID2, idset.active_tracker());
 582 }
 583
 584 TEST_F(MetadataDatabaseIndexOnDiskTest, DirtyTrackersTest) {
 585   CreateTestDatabase(true, NULL);
 586
 587   // Testing public methods
 588   EXPECT_EQ(1U, index()->CountDirtyTracker());
 589   EXPECT_FALSE(index()->HasDemotedDirtyTracker());
 590   EXPECT_EQ(kPlaceholderTrackerID, index()->PickDirtyTracker());
 591   index()->DemoteDirtyTracker(kPlaceholderTrackerID);
 592   WriteToDB();
 593   EXPECT_TRUE(index()->HasDemotedDirtyTracker());
 594   EXPECT_EQ(0U, index()->CountDirtyTracker());
 595
 596   const int64 tracker_id = 13;
 597   scoped_ptr<FileTracker> app_root_tracker(new FileTracker);
 598   index()->GetFileTracker(kAppRootTrackerID, app_root_tracker.get());
 599
 600   // Testing AddDirtyTrackerIndexes
 601   scoped_ptr<FileTracker> tracker =
 602       test_util::CreatePlaceholderTracker("placeholder",
 603                                           tracker_id,
 604                                           app_root_tracker.get());
 605   index()->StoreFileTracker(tracker.Pass());
 606   WriteToDB();
 607   EXPECT_EQ(1U, index()->CountDirtyTracker());
 608   EXPECT_EQ(tracker_id, index()->PickDirtyTracker());
 609
 610   // Testing UpdateDirtyTrackerIndexes
 611   tracker = test_util::CreatePlaceholderTracker("placeholder",
 612                                                 tracker_id,
 613                                                 app_root_tracker.get());
 614   tracker->set_dirty(false);
 615   index()->StoreFileTracker(tracker.Pass());
 616   WriteToDB();
 617   EXPECT_EQ(0U, index()->CountDirtyTracker());
 618   EXPECT_EQ(kInvalidTrackerID, index()->PickDirtyTracker());
 619
 620   tracker = test_util::CreatePlaceholderTracker("placeholder",
 621                                                 tracker_id,
 622                                                 app_root_tracker.get());
 623   index()->StoreFileTracker(tracker.Pass());
 624   WriteToDB();
 625   EXPECT_EQ(1U, index()->CountDirtyTracker());
 626   EXPECT_EQ(tracker_id, index()->PickDirtyTracker());
 627
 628   // Testing RemoveFromDirtyTrackerIndexes
 629   index()->RemoveFileTracker(tracker_id);
 630   WriteToDB();
 631   EXPECT_EQ(0U, index()->CountDirtyTracker());
 632   EXPECT_EQ(kInvalidTrackerID, index()->PickDirtyTracker());
 633
 634   // Demoted trackers
 635   EXPECT_TRUE(index()->HasDemotedDirtyTracker());
 636   EXPECT_TRUE(index()->PromoteDemotedDirtyTrackers());
 637   EXPECT_FALSE(index()->HasDemotedDirtyTracker());
 638 }
 639
 640 }  // namespace drive_backend
 641 }  // namespace sync_file_system