list_changes_task_unittest.cc revision 116680a4aac90f2aa7413d9095a592090648e557 
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 "base/thread_task_runner_handle.h"
13#include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
14#include "chrome/browser/sync_file_system/drive_backend/fake_drive_service_helper.h"
15#include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
16#include "chrome/browser/sync_file_system/drive_backend/register_app_task.h"
17#include "chrome/browser/sync_file_system/drive_backend/sync_engine_context.h"
18#include "chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.h"
19#include "chrome/browser/sync_file_system/drive_backend/sync_task_manager.h"
20#include "chrome/browser/sync_file_system/sync_file_system_test_util.h"
21#include "content/public/test/test_browser_thread_bundle.h"
22#include "google_apis/drive/drive_api_parser.h"
23#include "testing/gtest/include/gtest/gtest.h"
24#include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
25#include "third_party/leveldatabase/src/include/leveldb/env.h"
26
27namespace sync_file_system {
28namespace drive_backend {
29
30namespace {
31
32const char kAppID[] = "app_id";
33const char kUnregisteredAppID[] = "app_id unregistered";
34
35}  // namespace
36
37class ListChangesTaskTest : public testing::Test {
38 public:
39  ListChangesTaskTest() {}
40  virtual ~ListChangesTaskTest() {}
41
42  virtual void SetUp() OVERRIDE {
43    ASSERT_TRUE(database_dir_.CreateUniqueTempDir());
44    in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
45
46    scoped_ptr<drive::FakeDriveService>
47        fake_drive_service(new drive::FakeDriveService);
48
49    scoped_ptr<drive::DriveUploaderInterface>
50        drive_uploader(new drive::DriveUploader(
51            fake_drive_service.get(),
52            base::ThreadTaskRunnerHandle::Get()));
53
54    fake_drive_service_helper_.reset(
55        new FakeDriveServiceHelper(fake_drive_service.get(),
56                                   drive_uploader.get(),
57                                   kSyncRootFolderTitle));
58
59    sync_task_manager_.reset(new SyncTaskManager(
60        base::WeakPtr<SyncTaskManager::Client>(),
61        10 /* maximum_background_task */,
62        base::ThreadTaskRunnerHandle::Get()));
63    sync_task_manager_->Initialize(SYNC_STATUS_OK);
64
65    context_.reset(new SyncEngineContext(
66        fake_drive_service.PassAs<drive::DriveServiceInterface>(),
67        drive_uploader.Pass(),
68        NULL,
69        base::ThreadTaskRunnerHandle::Get(),
70        base::ThreadTaskRunnerHandle::Get(),
71        base::ThreadTaskRunnerHandle::Get()));
72
73    SetUpRemoteFolders();
74
75    InitializeMetadataDatabase();
76    RegisterApp(kAppID);
77  }
78
79  virtual void TearDown() OVERRIDE {
80    sync_task_manager_.reset();
81    context_.reset();
82    base::RunLoop().RunUntilIdle();
83  }
84
85 protected:
86  SyncStatusCode RunTask(scoped_ptr<SyncTask> sync_task) {
87    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
88    sync_task_manager_->ScheduleSyncTask(
89        FROM_HERE, sync_task.Pass(),
90        SyncTaskManager::PRIORITY_MED,
91        CreateResultReceiver(&status));
92    base::RunLoop().RunUntilIdle();
93    return status;
94  }
95
96  size_t CountDirtyTracker() {
97    return context_->GetMetadataDatabase()->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 context_->GetDriveService()->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  SyncEngineContext* GetSyncEngineContext() {
152    return context_.get();
153  }
154
155 private:
156  void SetUpRemoteFolders() {
157    ASSERT_EQ(google_apis::HTTP_CREATED,
158              fake_drive_service_helper_->AddOrphanedFolder(
159                  kSyncRootFolderTitle, &sync_root_folder_id_));
160    ASSERT_EQ(google_apis::HTTP_CREATED,
161              fake_drive_service_helper_->AddFolder(
162                  sync_root_folder_id_, kAppID, &app_root_folder_id_));
163    ASSERT_EQ(google_apis::HTTP_CREATED,
164              fake_drive_service_helper_->AddFolder(
165                  sync_root_folder_id_, kUnregisteredAppID,
166                  &unregistered_app_root_folder_id_));
167  }
168
169  void InitializeMetadataDatabase() {
170    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
171    SyncEngineInitializer* initializer =
172        new SyncEngineInitializer(context_.get(),
173                                  database_dir_.path(),
174                                  in_memory_env_.get());
175
176    sync_task_manager_->ScheduleSyncTask(
177        FROM_HERE, scoped_ptr<SyncTask>(initializer),
178        SyncTaskManager::PRIORITY_MED,
179        base::Bind(&ListChangesTaskTest::DidInitializeMetadataDatabase,
180                   base::Unretained(this), initializer, &status));
181
182    base::RunLoop().RunUntilIdle();
183
184    EXPECT_EQ(SYNC_STATUS_OK, status);
185  }
186
187  void DidInitializeMetadataDatabase(SyncEngineInitializer* initializer,
188                                     SyncStatusCode* status_out,
189                                     SyncStatusCode status) {
190    context_->SetMetadataDatabase(initializer->PassMetadataDatabase());
191    *status_out = status;
192  }
193
194  void RegisterApp(const std::string& app_id) {
195    EXPECT_EQ(SYNC_STATUS_OK, RunTask(scoped_ptr<SyncTask>(
196        new RegisterAppTask(context_.get(), app_id))));
197  }
198
199  scoped_ptr<leveldb::Env> in_memory_env_;
200
201  std::string sync_root_folder_id_;
202  std::string app_root_folder_id_;
203  std::string unregistered_app_root_folder_id_;
204
205  content::TestBrowserThreadBundle browser_threads_;
206  base::ScopedTempDir database_dir_;
207
208  scoped_ptr<SyncEngineContext> context_;
209  scoped_ptr<FakeDriveServiceHelper> fake_drive_service_helper_;
210
211  scoped_ptr<SyncTaskManager> sync_task_manager_;
212
213  DISALLOW_COPY_AND_ASSIGN(ListChangesTaskTest);
214};
215
216TEST_F(ListChangesTaskTest, NoChange) {
217  size_t num_dirty_trackers = CountDirtyTracker();
218
219  EXPECT_EQ(SYNC_STATUS_NO_CHANGE_TO_SYNC, RunTask(
220      scoped_ptr<SyncTask>(new ListChangesTask(GetSyncEngineContext()))));
221
222  EXPECT_EQ(num_dirty_trackers, CountDirtyTracker());
223}
224
225TEST_F(ListChangesTaskTest, UnrelatedChange) {
226  size_t num_dirty_trackers = CountDirtyTracker();
227
228  SetUpChangesInFolder(root_resource_id());
229  SetUpChangesInFolder(unregistered_app_root_folder_id());
230
231  EXPECT_EQ(SYNC_STATUS_OK, RunTask(
232      scoped_ptr<SyncTask>(new ListChangesTask(GetSyncEngineContext()))));
233
234  EXPECT_EQ(num_dirty_trackers, CountDirtyTracker());
235}
236
237TEST_F(ListChangesTaskTest, UnderTrackedFolder) {
238  size_t num_dirty_trackers = CountDirtyTracker();
239
240  SetUpChangesInFolder(app_root_folder_id());
241
242  EXPECT_EQ(SYNC_STATUS_OK, RunTask(
243      scoped_ptr<SyncTask>(new ListChangesTask(GetSyncEngineContext()))));
244
245  EXPECT_EQ(num_dirty_trackers + 4, CountDirtyTracker());
246}
247
248}  // namespace drive_backend
249}  // namespace sync_file_system
250