list_changes_task_unittest.cc revision a1401311d1ab56c4ed0a474bd38c108f75cb0cd9 
1// Copyright 2013 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/list_changes_task.h"
6
7#include <string>
8
9#include "base/files/scoped_temp_dir.h"
10#include "base/format_macros.h"
11#include "base/run_loop.h"
12#include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
13#include "chrome/browser/sync_file_system/drive_backend/fake_drive_service_helper.h"
14#include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
15#include "chrome/browser/sync_file_system/drive_backend/register_app_task.h"
16#include "chrome/browser/sync_file_system/drive_backend/sync_engine_context.h"
17#include "chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.h"
18#include "chrome/browser/sync_file_system/sync_file_system_test_util.h"
19#include "content/public/test/test_browser_thread_bundle.h"
20#include "google_apis/drive/drive_api_parser.h"
21#include "testing/gtest/include/gtest/gtest.h"
22#include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
23#include "third_party/leveldatabase/src/include/leveldb/env.h"
24
25namespace sync_file_system {
26namespace drive_backend {
27
28namespace {
29
30const char kAppID[] = "app_id";
31const char kUnregisteredAppID[] = "app_id unregistered";
32
33}  // namespace
34
35class ListChangesTaskTest : public testing::Test,
36                            public SyncEngineContext {
37 public:
38  ListChangesTaskTest() {}
39  virtual ~ListChangesTaskTest() {}
40
41  virtual void SetUp() OVERRIDE {
42    ASSERT_TRUE(database_dir_.CreateUniqueTempDir());
43    in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
44
45    fake_drive_service_.reset(new drive::FakeDriveService);
46    ASSERT_TRUE(fake_drive_service_->LoadAccountMetadataForWapi(
47        "sync_file_system/account_metadata.json"));
48    ASSERT_TRUE(fake_drive_service_->LoadResourceListForWapi(
49        "gdata/empty_feed.json"));
50
51    drive_uploader_.reset(new drive::DriveUploader(
52        fake_drive_service_.get(), base::MessageLoopProxy::current()));
53
54    fake_drive_service_helper_.reset(new FakeDriveServiceHelper(
55        fake_drive_service_.get(), drive_uploader_.get(),
56        kSyncRootFolderTitle));
57
58    SetUpRemoteFolders();
59    InitializeMetadataDatabase();
60    RegisterApp(kAppID);
61  }
62
63  virtual void TearDown() OVERRIDE {
64    metadata_database_.reset();
65    base::RunLoop().RunUntilIdle();
66  }
67
68  virtual drive::DriveServiceInterface* GetDriveService() OVERRIDE {
69    return fake_drive_service_.get();
70  }
71
72  virtual drive::DriveUploader* GetDriveUploader() OVERRIDE {
73    return NULL;
74  }
75
76  virtual MetadataDatabase* GetMetadataDatabase() OVERRIDE {
77    return metadata_database_.get();
78  }
79
80  virtual RemoteChangeProcessor* GetRemoteChangeProcessor() OVERRIDE {
81    return NULL;
82  }
83
84  virtual base::SequencedTaskRunner* GetBlockingTaskRunner() OVERRIDE {
85    return base::MessageLoopProxy::current();
86  }
87
88 protected:
89  SyncStatusCode RunTask(SequentialSyncTask* sync_task) {
90    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
91    sync_task->RunSequential(CreateResultReceiver(&status));
92    base::RunLoop().RunUntilIdle();
93    return status;
94  }
95
96  size_t CountDirtyTracker() {
97    return metadata_database_->CountDirtyTracker();
98  }
99
100  FakeDriveServiceHelper* fake_drive_service_helper() {
101    return fake_drive_service_helper_.get();
102  }
103
104  void SetUpChangesInFolder(const std::string& folder_id) {
105    std::string new_file_id;
106    ASSERT_EQ(google_apis::HTTP_SUCCESS,
107              fake_drive_service_helper()->AddFile(
108                  folder_id, "new file", "file contents", &new_file_id));
109    std::string same_name_file_id;
110    ASSERT_EQ(google_apis::HTTP_SUCCESS,
111              fake_drive_service_helper()->AddFile(
112                  folder_id, "new file", "file contents",
113                  &same_name_file_id));
114
115    std::string new_folder_id;
116    ASSERT_EQ(google_apis::HTTP_CREATED,
117              fake_drive_service_helper()->AddFolder(
118                  folder_id, "new folder", &new_folder_id));
119
120    std::string modified_file_id;
121    ASSERT_EQ(google_apis::HTTP_SUCCESS,
122              fake_drive_service_helper()->AddFile(
123                  folder_id, "modified file", "file content",
124                  &modified_file_id));
125    ASSERT_EQ(google_apis::HTTP_SUCCESS,
126              fake_drive_service_helper()->UpdateFile(
127                  modified_file_id, "modified file content"));
128
129
130    std::string deleted_file_id;
131    ASSERT_EQ(google_apis::HTTP_SUCCESS,
132              fake_drive_service_helper()->AddFile(
133                  folder_id, "trashed file", "file content",
134                  &deleted_file_id));
135    ASSERT_EQ(google_apis::HTTP_NO_CONTENT,
136              fake_drive_service_helper()->DeleteResource(deleted_file_id));
137  }
138
139  std::string root_resource_id() {
140    return fake_drive_service_->GetRootResourceId();
141  }
142
143  std::string app_root_folder_id() {
144    return app_root_folder_id_;
145  }
146
147  std::string unregistered_app_root_folder_id() {
148    return unregistered_app_root_folder_id_;
149  }
150
151 private:
152  void SetUpRemoteFolders() {
153    ASSERT_EQ(google_apis::HTTP_CREATED,
154              fake_drive_service_helper_->AddOrphanedFolder(
155                  kSyncRootFolderTitle, &sync_root_folder_id_));
156    ASSERT_EQ(google_apis::HTTP_CREATED,
157              fake_drive_service_helper_->AddFolder(
158                  sync_root_folder_id_, kAppID, &app_root_folder_id_));
159    ASSERT_EQ(google_apis::HTTP_CREATED,
160              fake_drive_service_helper_->AddFolder(
161                  sync_root_folder_id_, kUnregisteredAppID,
162                  &unregistered_app_root_folder_id_));
163  }
164
165  void InitializeMetadataDatabase() {
166    SyncEngineInitializer initializer(this,
167                                      base::MessageLoopProxy::current(),
168                                      fake_drive_service_.get(),
169                                      database_dir_.path(),
170                                      in_memory_env_.get());
171    EXPECT_EQ(SYNC_STATUS_OK, RunTask(&initializer));
172    metadata_database_ = initializer.PassMetadataDatabase();
173  }
174
175  void RegisterApp(const std::string& app_id) {
176    RegisterAppTask register_app(this, app_id);
177    EXPECT_EQ(SYNC_STATUS_OK, RunTask(&register_app));
178  }
179
180  scoped_ptr<leveldb::Env> in_memory_env_;
181
182  std::string sync_root_folder_id_;
183  std::string app_root_folder_id_;
184  std::string unregistered_app_root_folder_id_;
185
186  content::TestBrowserThreadBundle browser_threads_;
187  base::ScopedTempDir database_dir_;
188
189  scoped_ptr<drive::FakeDriveService> fake_drive_service_;
190  scoped_ptr<drive::DriveUploader> drive_uploader_;
191  scoped_ptr<FakeDriveServiceHelper> fake_drive_service_helper_;
192
193  scoped_ptr<MetadataDatabase> metadata_database_;
194
195  DISALLOW_COPY_AND_ASSIGN(ListChangesTaskTest);
196};
197
198TEST_F(ListChangesTaskTest, NoChange) {
199  size_t num_dirty_trackers = CountDirtyTracker();
200
201  ListChangesTask list_changes(this);
202  EXPECT_EQ(SYNC_STATUS_NO_CHANGE_TO_SYNC, RunTask(&list_changes));
203
204  EXPECT_EQ(num_dirty_trackers, CountDirtyTracker());
205}
206
207TEST_F(ListChangesTaskTest, UnrelatedChange) {
208  size_t num_dirty_trackers = CountDirtyTracker();
209
210  SetUpChangesInFolder(root_resource_id());
211  SetUpChangesInFolder(unregistered_app_root_folder_id());
212
213  ListChangesTask list_changes(this);
214  EXPECT_EQ(SYNC_STATUS_OK, RunTask(&list_changes));
215
216  EXPECT_EQ(num_dirty_trackers, CountDirtyTracker());
217}
218
219TEST_F(ListChangesTaskTest, UnderTrackedFolder) {
220  size_t num_dirty_trackers = CountDirtyTracker();
221
222  SetUpChangesInFolder(app_root_folder_id());
223
224  ListChangesTask list_changes(this);
225  EXPECT_EQ(SYNC_STATUS_OK, RunTask(&list_changes));
226
227  EXPECT_EQ(num_dirty_trackers + 4, CountDirtyTracker());
228}
229
230}  // namespace drive_backend
231}  // namespace sync_file_system
232