metadata_database_index_unittest.cc revision a1401311d1ab56c4ed0a474bd38c108f75cb0cd9 
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.h"
6
7#include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
8#include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
9#include "testing/gtest/include/gtest/gtest.h"
10
11namespace sync_file_system {
12namespace drive_backend {
13
14namespace {
15
16const int64 kSyncRootTrackerID = 1;
17const int64 kAppRootTrackerID = 2;
18const int64 kFileTrackerID = 3;
19const int64 kPlaceholderTrackerID = 4;
20
21scoped_ptr<FileMetadata> CreateFolderMetadata(const std::string& file_id,
22                                              const std::string& title) {
23  FileDetails details;
24  details.set_title(title);
25  details.set_file_kind(FILE_KIND_FOLDER);
26  details.set_missing(false);
27
28  scoped_ptr<FileMetadata> metadata(new FileMetadata);
29  metadata->set_file_id(file_id);
30  *metadata->mutable_details() = details;
31
32  return metadata.Pass();
33}
34
35scoped_ptr<FileMetadata> CreateFileMetadata(const std::string& file_id,
36                                            const std::string& title,
37                                            const std::string& md5) {
38  FileDetails details;
39  details.set_title(title);
40  details.set_file_kind(FILE_KIND_FILE);
41  details.set_missing(false);
42  details.set_md5(md5);
43
44  scoped_ptr<FileMetadata> metadata(new FileMetadata);
45  metadata->set_file_id(file_id);
46  *metadata->mutable_details() = details;
47
48  return metadata.Pass();
49}
50
51scoped_ptr<FileTracker> CreateTracker(const FileMetadata& metadata,
52                                      int64 tracker_id,
53                                      const FileTracker* parent_tracker) {
54  scoped_ptr<FileTracker> tracker(new FileTracker);
55  tracker->set_tracker_id(tracker_id);
56  if (parent_tracker)
57    tracker->set_parent_tracker_id(parent_tracker->tracker_id());
58  tracker->set_file_id(metadata.file_id());
59  if (parent_tracker)
60    tracker->set_app_id(parent_tracker->app_id());
61  tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
62  *tracker->mutable_synced_details() = metadata.details();
63  tracker->set_dirty(false);
64  tracker->set_active(true);
65  tracker->set_needs_folder_listing(false);
66  return tracker.Pass();
67}
68
69scoped_ptr<FileTracker> CreatePlaceholderTracker(
70    const std::string& file_id,
71    int64 tracker_id,
72    const FileTracker* parent_tracker) {
73  scoped_ptr<FileTracker> tracker(new FileTracker);
74  tracker->set_tracker_id(tracker_id);
75  if (parent_tracker)
76    tracker->set_parent_tracker_id(parent_tracker->tracker_id());
77  tracker->set_file_id(file_id);
78  if (parent_tracker)
79    tracker->set_app_id(parent_tracker->app_id());
80  tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
81  tracker->set_dirty(true);
82  tracker->set_active(false);
83  tracker->set_needs_folder_listing(false);
84  return tracker.Pass();
85}
86
87scoped_ptr<DatabaseContents> CreateTestDatabaseContents() {
88  scoped_ptr<DatabaseContents> contents(new DatabaseContents);
89
90  scoped_ptr<FileMetadata> sync_root_metadata =
91      CreateFolderMetadata("sync_root_folder_id",
92                           "Chrome Syncable FileSystem");
93  scoped_ptr<FileTracker> sync_root_tracker =
94      CreateTracker(*sync_root_metadata, kSyncRootTrackerID, NULL);
95
96  scoped_ptr<FileMetadata> app_root_metadata =
97      CreateFolderMetadata("app_root_folder_id", "app_id");
98  scoped_ptr<FileTracker> app_root_tracker =
99      CreateTracker(*app_root_metadata, kAppRootTrackerID,
100                    sync_root_tracker.get());
101  app_root_tracker->set_app_id("app_id");
102  app_root_tracker->set_tracker_kind(TRACKER_KIND_APP_ROOT);
103
104  scoped_ptr<FileMetadata> file_metadata =
105      CreateFileMetadata("file_id", "file", "file_md5");
106  scoped_ptr<FileTracker> file_tracker =
107      CreateTracker(*file_metadata, kFileTrackerID, app_root_tracker.get());
108
109  scoped_ptr<FileTracker> placeholder_tracker =
110      CreatePlaceholderTracker("unsynced_file_id", kPlaceholderTrackerID,
111                               app_root_tracker.get());
112
113  contents->file_metadata.push_back(sync_root_metadata.release());
114  contents->file_trackers.push_back(sync_root_tracker.release());
115  contents->file_metadata.push_back(app_root_metadata.release());
116  contents->file_trackers.push_back(app_root_tracker.release());
117  contents->file_metadata.push_back(file_metadata.release());
118  contents->file_trackers.push_back(file_tracker.release());
119  contents->file_trackers.push_back(placeholder_tracker.release());
120  return contents.Pass();
121}
122
123}  // namespace
124
125TEST(MetadataDatabaseIndexTest, GetEntryTest) {
126  MetadataDatabaseIndex index(CreateTestDatabaseContents().get());
127
128  EXPECT_FALSE(index.GetFileMetadata(std::string()));
129  EXPECT_FALSE(index.GetFileTracker(kInvalidTrackerID));
130
131  const FileTracker* tracker = index.GetFileTracker(kFileTrackerID);
132  ASSERT_TRUE(tracker);
133  EXPECT_EQ(kFileTrackerID, tracker->tracker_id());
134  EXPECT_EQ("file_id", tracker->file_id());
135
136  const FileMetadata* metadata = index.GetFileMetadata("file_id");
137  ASSERT_TRUE(metadata);
138  EXPECT_EQ("file_id", metadata->file_id());
139}
140
141TEST(MetadataDatabaseIndexTest, IndexLookUpTest) {
142  MetadataDatabaseIndex index(CreateTestDatabaseContents().get());
143
144  TrackerIDSet trackers = index.GetFileTrackerIDsByFileID("file_id");
145  EXPECT_EQ(1u, trackers.size());
146  EXPECT_TRUE(trackers.has_active());
147  EXPECT_EQ(kFileTrackerID, trackers.active_tracker());
148
149  int64 app_root_tracker_id = index.GetAppRootTracker("app_id");
150  EXPECT_EQ(kAppRootTrackerID, app_root_tracker_id);
151
152  trackers = index.GetFileTrackerIDsByParentAndTitle(
153      app_root_tracker_id, "file");
154  EXPECT_EQ(1u, trackers.size());
155  EXPECT_TRUE(trackers.has_active());
156  EXPECT_EQ(kFileTrackerID, trackers.active_tracker());
157
158  EXPECT_TRUE(index.PickMultiTrackerFileID().empty());
159  EXPECT_EQ(kInvalidTrackerID,
160            index.PickMultiBackingFilePath().parent_id);
161  EXPECT_EQ(kPlaceholderTrackerID, index.PickDirtyTracker());
162}
163
164TEST(MetadataDatabaseIndexTest, UpdateTest) {
165  MetadataDatabaseIndex index(CreateTestDatabaseContents().get());
166
167  index.DemoteDirtyTracker(kPlaceholderTrackerID);
168  EXPECT_EQ(kInvalidTrackerID, index.PickDirtyTracker());
169  index.PromoteDemotedDirtyTrackers();
170  EXPECT_EQ(kPlaceholderTrackerID, index.PickDirtyTracker());
171
172  int64 new_tracker_id = 100;
173  scoped_ptr<FileTracker> new_tracker =
174      CreateTracker(*index.GetFileMetadata("file_id"),
175                    new_tracker_id,
176                    index.GetFileTracker(kAppRootTrackerID));
177  new_tracker->set_active(false);
178  index.StoreFileTracker(new_tracker.Pass());
179
180  EXPECT_EQ("file_id", index.PickMultiTrackerFileID());
181  EXPECT_EQ(ParentIDAndTitle(kAppRootTrackerID, std::string("file")),
182            index.PickMultiBackingFilePath());
183
184  index.RemoveFileMetadata("file_id");
185  index.RemoveFileTracker(kFileTrackerID);
186
187  EXPECT_FALSE(index.GetFileMetadata("file_id"));
188  EXPECT_FALSE(index.GetFileTracker(kFileTrackerID));
189}
190
191}  // namespace drive_backend
192}  // namespace sync_file_system
193