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