[SyncFS] Test MetadataDatabaseTest using both on-memory and on-disk indexes

chrome/browser/sync_file_system/drive_backend/metadata_database_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 151 matching lines @@
     ++right_itr;
   }
 }
 
 base::FilePath CreateNormalizedPath(const base::FilePath::StringType& path) {
   return base::FilePath(path).NormalizePathSeparators();
 }
 
 }  // namespace
 
-class MetadataDatabaseTest : public testing::Test {
+class MetadataDatabaseTest : public testing::TestWithParam<bool> {
  public:
   MetadataDatabaseTest()
       : current_change_id_(kInitialChangeID),
         next_tracker_id_(kSyncRootTrackerID + 1),
         next_file_id_number_(1),
         next_md5_sequence_number_(1) {}
 
   virtual ~MetadataDatabaseTest() {}
 
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(database_dir_.CreateUniqueTempDir());

[nhiroki, 2014/09/10 05:58:55]

(Not related to this CL) We don't have to create temporary database dircectory
if we use only the in-memory env.

[peria, 2014/09/10 06:16:47]

Acknowledged.

The path of database file is checked in MetadataDatabase::OpenDatabase(),
and it seems not easy to pass it without CreateUniqueTempDir().
Let me consider how to handle it.
(I'll do in another CL, if I work for it.)

     in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
   }
 
   virtual void TearDown() OVERRIDE { DropDatabase(); }
 
  protected:
   std::string GenerateFileID() {
     return "file_id_" + base::Int64ToString(next_file_id_number_++);
   }
 
   int64 GetTrackerIDByFileID(const std::string& file_id) {
     TrackerIDSet trackers;
     if (metadata_database_->FindTrackersByFileID(file_id, &trackers)) {
       EXPECT_FALSE(trackers.empty());
       return *trackers.begin();
     }
     return 0;
   }
 
   SyncStatusCode InitializeMetadataDatabase() {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
-    metadata_database_ = MetadataDatabase::Create(
-        database_dir_.path(), in_memory_env_.get(), &status);
+    metadata_database_ = MetadataDatabase::CreateInternal(
+        database_dir_.path(), in_memory_env_.get(),
+        GetParam(), &status);
     return status;
   }
 
   void DropDatabase() {
     metadata_database_.reset();
     message_loop_.RunUntilIdle();
   }
 
   void SetUpDatabaseByTrackedFiles(const TrackedFile** tracked_files,
                                    int size) {
@@ skipping 296 matching lines @@
     scoped_ptr<MetadataDatabase> metadata_database_2;
     ASSERT_EQ(SYNC_STATUS_OK,
               MetadataDatabase::CreateForTesting(
                   metadata_database_->db_.Pass(),
                   metadata_database_->enable_on_disk_index_,
                   &metadata_database_2));
     metadata_database_->db_ = metadata_database_2->db_.Pass();
 
     MetadataDatabaseIndexInterface* index1 = metadata_database_->index_.get();
     MetadataDatabaseIndexInterface* index2 = metadata_database_2->index_.get();
-    if (metadata_database_->enable_on_disk_index_) {
+    if (GetParam()) {
       VerifyReloadConsistencyForOnDisk(
           static_cast<MetadataDatabaseIndexOnDisk*>(index1),
           static_cast<MetadataDatabaseIndexOnDisk*>(index2));
     } else {
       VerifyReloadConsistencyForOnMemory(
           static_cast<MetadataDatabaseIndex*>(index1),
           static_cast<MetadataDatabaseIndex*>(index2));
     }
   }
 
@@ skipping 74 matching lines @@
   scoped_ptr<MetadataDatabase> metadata_database_;
 
   int64 current_change_id_;
   int64 next_tracker_id_;
   int64 next_file_id_number_;
   int64 next_md5_sequence_number_;
 
   DISALLOW_COPY_AND_ASSIGN(MetadataDatabaseTest);
 };
 
-TEST_F(MetadataDatabaseTest, InitializationTest_Empty) {
+INSTANTIATE_TEST_CASE_P(MetadataDatabaseTestWithIndexesOnDisk,
+                        MetadataDatabaseTest,
+                        ::testing::Values(true, false));
+
+TEST_P(MetadataDatabaseTest, InitializationTest_Empty) {
   EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
   DropDatabase();
   EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
 
   DropDatabase();
 
   scoped_ptr<LevelDBWrapper> db = InitializeLevelDB();
   db->Put(kServiceMetadataKey, "Unparsable string");
   EXPECT_TRUE(db->Commit().ok());
   db.reset();
 
   EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
 }
 
-TEST_F(MetadataDatabaseTest, InitializationTest_SimpleTree) {
+TEST_P(MetadataDatabaseTest, InitializationTest_SimpleTree) {
   TrackedFile sync_root(CreateTrackedSyncRoot());
   TrackedFile app_root(CreateTrackedFolder(sync_root, "app_id"));
   app_root.tracker.set_app_id(app_root.metadata.details().title());
   app_root.tracker.set_tracker_kind(TRACKER_KIND_APP_ROOT);
 
   TrackedFile file(CreateTrackedFile(app_root, "file"));
   TrackedFile folder(CreateTrackedFolder(app_root, "folder"));
   TrackedFile file_in_folder(CreateTrackedFile(folder, "file_in_folder"));
   TrackedFile orphaned_file(CreateTrackedFile(sync_root, "orphaned_file"));
   orphaned_file.metadata.mutable_details()->clear_parent_folder_ids();
   orphaned_file.tracker.set_parent_tracker_id(0);
 
   const TrackedFile* tracked_files[] = {
     &sync_root, &app_root, &file, &folder, &file_in_folder, &orphaned_file
   };
 
   SetUpDatabaseByTrackedFiles(tracked_files, arraysize(tracked_files));
   EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
 
   orphaned_file.should_be_absent = true;
   VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
 }
 
-TEST_F(MetadataDatabaseTest, AppManagementTest) {
+TEST_P(MetadataDatabaseTest, AppManagementTest) {
   TrackedFile sync_root(CreateTrackedSyncRoot());
   TrackedFile app_root(CreateTrackedFolder(sync_root, "app_id"));
   app_root.tracker.set_app_id(app_root.metadata.details().title());
   app_root.tracker.set_tracker_kind(TRACKER_KIND_APP_ROOT);
 
   TrackedFile file(CreateTrackedFile(app_root, "file"));
   TrackedFile folder(CreateTrackedFolder(sync_root, "folder"));
   folder.tracker.set_active(false);
 
   const TrackedFile* tracked_files[] = {
@@ skipping 34 matching lines @@
   app_root.tracker.set_app_id(std::string());
   app_root.tracker.set_tracker_kind(TRACKER_KIND_REGULAR);
   app_root.tracker.set_active(false);
   app_root.tracker.set_dirty(true);
   file.should_be_absent = true;
   VerifyTrackedFile(app_root);
   VerifyTrackedFile(file);
   VerifyReloadConsistency();
 }
 
-TEST_F(MetadataDatabaseTest, BuildPathTest) {
+TEST_P(MetadataDatabaseTest, BuildPathTest) {
   FileMetadata sync_root(CreateSyncRootMetadata());
   FileTracker sync_root_tracker(CreateSyncRootTracker(sync_root));
 
   FileMetadata app_root(CreateFolderMetadata(sync_root, "app_id"));
   FileTracker app_root_tracker(
       CreateTracker(sync_root_tracker, app_root));
   app_root_tracker.set_app_id(app_root.details().title());
   app_root_tracker.set_tracker_kind(TRACKER_KIND_APP_ROOT);
 
   FileMetadata folder(CreateFolderMetadata(app_root, "folder"));
@@ skipping 28 matching lines @@
       sync_root_tracker.tracker_id(), &path));
   EXPECT_TRUE(metadata_database()->BuildPathForTracker(
       app_root_tracker.tracker_id(), &path));
   EXPECT_EQ(base::FilePath(FPL("/")).NormalizePathSeparators(), path);
   EXPECT_TRUE(metadata_database()->BuildPathForTracker(
       file_tracker.tracker_id(), &path));
   EXPECT_EQ(base::FilePath(FPL("/folder/file")).NormalizePathSeparators(),
             path);
 }
 
-TEST_F(MetadataDatabaseTest, FindNearestActiveAncestorTest) {
+TEST_P(MetadataDatabaseTest, FindNearestActiveAncestorTest) {
   const std::string kAppID = "app_id";
 
   FileMetadata sync_root(CreateSyncRootMetadata());
   FileTracker sync_root_tracker(CreateSyncRootTracker(sync_root));
 
   FileMetadata app_root(CreateFolderMetadata(sync_root, kAppID));
   FileTracker app_root_tracker(
       CreateTracker(sync_root_tracker, app_root));
   app_root_tracker.set_app_id(app_root.details().title());
   app_root_tracker.set_tracker_kind(TRACKER_KIND_APP_ROOT);
@@ skipping 84 matching lines @@
     base::FilePath path;
     FileTracker tracker;
     EXPECT_TRUE(metadata_database()->FindNearestActiveAncestor(
         kAppID, CreateNormalizedPath(FPL("folder1/folder2/file/folder4/file")),
         &tracker, &path));
     EXPECT_EQ(folder_tracker2.tracker_id(), tracker.tracker_id());
     EXPECT_EQ(CreateNormalizedPath(FPL("folder1/folder2")), path);
   }
 }
 
-TEST_F(MetadataDatabaseTest, UpdateByChangeListTest) {
+TEST_P(MetadataDatabaseTest, UpdateByChangeListTest) {
   TrackedFile sync_root(CreateTrackedSyncRoot());
   TrackedFile app_root(CreateTrackedFolder(sync_root, "app_id"));
   TrackedFile disabled_app_root(CreateTrackedFolder(sync_root, "disabled_app"));
   TrackedFile file(CreateTrackedFile(app_root, "file"));
   TrackedFile renamed_file(CreateTrackedFile(app_root, "to be renamed"));
   TrackedFile folder(CreateTrackedFolder(app_root, "folder"));
   TrackedFile reorganized_file(
       CreateTrackedFile(app_root, "to be reorganized"));
   TrackedFile updated_file(
       CreateTrackedFile(app_root, "to be updated"));
@@ skipping 41 matching lines @@
   new_file.tracker.set_dirty(true);
   ResetTrackerID(&new_file.tracker);
   EXPECT_NE(0, new_file.tracker.tracker_id());
 
   new_file.should_be_absent = false;
 
   VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
   VerifyReloadConsistency();
 }
 
-TEST_F(MetadataDatabaseTest, PopulateFolderTest_RegularFolder) {
+TEST_P(MetadataDatabaseTest, PopulateFolderTest_RegularFolder) {
   TrackedFile sync_root(CreateTrackedSyncRoot());
   TrackedFile app_root(CreateTrackedAppRoot(sync_root, "app_id"));
   app_root.tracker.set_app_id(app_root.metadata.details().title());
 
   TrackedFile folder_to_populate(
       CreateTrackedFolder(app_root, "folder_to_populate"));
   folder_to_populate.tracker.set_needs_folder_listing(true);
   folder_to_populate.tracker.set_dirty(true);
 
   TrackedFile known_file(CreateTrackedFile(folder_to_populate, "known_file"));
@@ skipping 21 matching lines @@
   ResetTrackerID(&new_file.tracker);
   new_file.tracker.set_dirty(true);
   new_file.tracker.set_active(false);
   new_file.tracker.clear_synced_details();
   new_file.should_be_absent = false;
   new_file.tracker_only = true;
   VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
   VerifyReloadConsistency();
 }
 
-TEST_F(MetadataDatabaseTest, PopulateFolderTest_InactiveFolder) {
+TEST_P(MetadataDatabaseTest, PopulateFolderTest_InactiveFolder) {
   TrackedFile sync_root(CreateTrackedSyncRoot());
   TrackedFile app_root(CreateTrackedAppRoot(sync_root, "app_id"));
 
   TrackedFile inactive_folder(CreateTrackedFolder(app_root, "inactive_folder"));
   inactive_folder.tracker.set_active(false);
   inactive_folder.tracker.set_dirty(true);
 
   TrackedFile new_file(
       CreateTrackedFile(inactive_folder, "file_in_inactive_folder"));
   new_file.should_be_absent = true;
 
   const TrackedFile* tracked_files[] = {
     &sync_root, &app_root, &inactive_folder, &new_file,
   };
 
   SetUpDatabaseByTrackedFiles(tracked_files, arraysize(tracked_files));
   EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
   VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
 
   FileIDList listed_children;
   listed_children.push_back(new_file.metadata.file_id());
 
   EXPECT_EQ(SYNC_STATUS_OK,
             PopulateFolder(inactive_folder.metadata.file_id(),
                            listed_children));
   VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
   VerifyReloadConsistency();
 }
 
-TEST_F(MetadataDatabaseTest, PopulateFolderTest_DisabledAppRoot) {
+TEST_P(MetadataDatabaseTest, PopulateFolderTest_DisabledAppRoot) {
   TrackedFile sync_root(CreateTrackedSyncRoot());
   TrackedFile disabled_app_root(
       CreateTrackedAppRoot(sync_root, "disabled_app"));
   disabled_app_root.tracker.set_dirty(true);
   disabled_app_root.tracker.set_needs_folder_listing(true);
 
   TrackedFile known_file(CreateTrackedFile(disabled_app_root, "known_file"));
   TrackedFile file(CreateTrackedFile(disabled_app_root, "file"));
   file.should_be_absent = true;
 
@@ skipping 16 matching lines @@
   file.should_be_absent = false;
   file.tracker_only = true;
 
   disabled_app_root.tracker.set_dirty(false);
   disabled_app_root.tracker.set_needs_folder_listing(false);
   VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
   VerifyReloadConsistency();
 }
 
 // TODO(tzik): Fix expectation and re-enable this test.
-TEST_F(MetadataDatabaseTest, DISABLED_UpdateTrackerTest) {
+TEST_P(MetadataDatabaseTest, DISABLED_UpdateTrackerTest) {
   TrackedFile sync_root(CreateTrackedSyncRoot());
   TrackedFile app_root(CreateTrackedAppRoot(sync_root, "app_root"));
   TrackedFile file(CreateTrackedFile(app_root, "file"));
   file.tracker.set_dirty(true);
   file.metadata.mutable_details()->set_title("renamed file");
 
   TrackedFile inactive_file(CreateTrackedFile(app_root, "inactive_file"));
   inactive_file.tracker.set_active(false);
   inactive_file.tracker.set_dirty(true);
   inactive_file.metadata.mutable_details()->set_title("renamed inactive file");
@@ skipping 30 matching lines @@
        new_conflict.metadata.details();
   new_conflict.tracker.set_dirty(false);
   new_conflict.tracker.set_active(true);
   file.tracker.set_dirty(true);
   file.tracker.set_active(false);
   EXPECT_EQ(SYNC_STATUS_OK, UpdateTracker(new_conflict.tracker));
   VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
   VerifyReloadConsistency();
 }
 
-TEST_F(MetadataDatabaseTest, PopulateInitialDataTest) {
+TEST_P(MetadataDatabaseTest, PopulateInitialDataTest) {
   TrackedFile sync_root(CreateTrackedSyncRoot());
   TrackedFile app_root(CreateTrackedFolder(sync_root, "app_root"));
   app_root.tracker.set_active(false);
 
   const TrackedFile* tracked_files[] = {
     &sync_root, &app_root
   };
 
   scoped_ptr<google_apis::FileResource> sync_root_folder(
       CreateFileResourceFromMetadata(sync_root.metadata));
@@ skipping 10 matching lines @@
       app_root_folders));
 
   ResetTrackerID(&sync_root.tracker);
   ResetTrackerID(&app_root.tracker);
   app_root.tracker.set_parent_tracker_id(sync_root.tracker.tracker_id());
 
   VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
   VerifyReloadConsistency();
 }
 
-TEST_F(MetadataDatabaseTest, DumpFiles) {
+TEST_P(MetadataDatabaseTest, DumpFiles) {
   TrackedFile sync_root(CreateTrackedSyncRoot());
   TrackedFile app_root(CreateTrackedAppRoot(sync_root, "app_id"));
   app_root.tracker.set_app_id(app_root.metadata.details().title());
 
   TrackedFile folder_0(CreateTrackedFolder(app_root, "folder_0"));
   TrackedFile file_0(CreateTrackedFile(folder_0, "file_0"));
 
   const TrackedFile* tracked_files[] = {
     &sync_root, &app_root, &folder_0, &file_0
   };
@@ skipping 15 matching lines @@
   EXPECT_TRUE(file->HasKey("details"));
 
   ASSERT_TRUE(files->GetDictionary(1, &file));
   EXPECT_TRUE(file->GetString("title", &str) && str == "file_0");
   EXPECT_TRUE(file->GetString("type", &str) && str == "file");
   EXPECT_TRUE(file->HasKey("details"));
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system