list_changes_task_unittest.cc revision 010d83a9304c5a91596085d917d248abff47903a 
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/drive_backend/sync_task_manager.h"
19#include "chrome/browser/sync_file_system/sync_file_system_test_util.h"
20#include "content/public/test/test_browser_thread_bundle.h"
21#include "google_apis/drive/drive_api_parser.h"
22#include "testing/gtest/include/gtest/gtest.h"
23#include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
24#include "third_party/leveldatabase/src/include/leveldb/env.h"
25
26namespace sync_file_system {
27namespace drive_backend {
28
29namespace {
30
31const char kAppID[] = "app_id";
32const char kUnregisteredAppID[] = "app_id unregistered";
33
34}  // namespace
35
36class ListChangesTaskTest : public testing::Test {
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    scoped_ptr<drive::FakeDriveService>
46        fake_drive_service(new drive::FakeDriveService);
47
48    scoped_ptr<drive::DriveUploaderInterface>
49        drive_uploader(new drive::DriveUploader(
50            fake_drive_service.get(),
51            base::MessageLoopProxy::current()));
52
53    fake_drive_service_helper_.reset(
54        new FakeDriveServiceHelper(fake_drive_service.get(),
55                                   drive_uploader.get(),
56                                   kSyncRootFolderTitle));
57
58    sync_task_manager_.reset(new SyncTaskManager(
59        base::WeakPtr<SyncTaskManager::Client>(),
60        10 /* maximum_background_task */));
61    sync_task_manager_->Initialize(SYNC_STATUS_OK);
62
63    context_.reset(new SyncEngineContext(
64        fake_drive_service.PassAs<drive::DriveServiceInterface>(),
65        drive_uploader.Pass(),
66        base::MessageLoopProxy::current(),
67        base::MessageLoopProxy::current(),
68        base::MessageLoopProxy::current()));
69
70    SetUpRemoteFolders();
71
72    InitializeMetadataDatabase();
73    RegisterApp(kAppID);
74  }
75
76  virtual void TearDown() OVERRIDE {
77    sync_task_manager_.reset();
78    context_.reset();
79    base::RunLoop().RunUntilIdle();
80  }
81
82 protected:
83  SyncStatusCode RunTask(scoped_ptr<SyncTask> sync_task) {
84    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
85    sync_task_manager_->ScheduleSyncTask(
86        FROM_HERE, sync_task.Pass(),
87        SyncTaskManager::PRIORITY_MED,
88        CreateResultReceiver(&status));
89    base::RunLoop().RunUntilIdle();
90    return status;
91  }
92
93  size_t CountDirtyTracker() {
94    return context_->GetMetadataDatabase()->CountDirtyTracker();
95  }
96
97  FakeDriveServiceHelper* fake_drive_service_helper() {
98    return fake_drive_service_helper_.get();
99  }
100
101  void SetUpChangesInFolder(const std::string& folder_id) {
102    std::string new_file_id;
103    ASSERT_EQ(google_apis::HTTP_SUCCESS,
104              fake_drive_service_helper()->AddFile(
105                  folder_id, "new file", "file contents", &new_file_id));
106    std::string same_name_file_id;
107    ASSERT_EQ(google_apis::HTTP_SUCCESS,
108              fake_drive_service_helper()->AddFile(
109                  folder_id, "new file", "file contents",
110                  &same_name_file_id));
111
112    std::string new_folder_id;
113    ASSERT_EQ(google_apis::HTTP_CREATED,
114              fake_drive_service_helper()->AddFolder(
115                  folder_id, "new folder", &new_folder_id));
116
117    std::string modified_file_id;
118    ASSERT_EQ(google_apis::HTTP_SUCCESS,
119              fake_drive_service_helper()->AddFile(
120                  folder_id, "modified file", "file content",
121                  &modified_file_id));
122    ASSERT_EQ(google_apis::HTTP_SUCCESS,
123              fake_drive_service_helper()->UpdateFile(
124                  modified_file_id, "modified file content"));
125
126
127    std::string deleted_file_id;
128    ASSERT_EQ(google_apis::HTTP_SUCCESS,
129              fake_drive_service_helper()->AddFile(
130                  folder_id, "trashed file", "file content",
131                  &deleted_file_id));
132    ASSERT_EQ(google_apis::HTTP_NO_CONTENT,
133              fake_drive_service_helper()->DeleteResource(deleted_file_id));
134  }
135
136  std::string root_resource_id() {
137    return context_->GetDriveService()->GetRootResourceId();
138  }
139
140  std::string app_root_folder_id() {
141    return app_root_folder_id_;
142  }
143
144  std::string unregistered_app_root_folder_id() {
145    return unregistered_app_root_folder_id_;
146  }
147
148  SyncEngineContext* GetSyncEngineContext() {
149    return context_.get();
150  }
151
152 private:
153  void SetUpRemoteFolders() {
154    ASSERT_EQ(google_apis::HTTP_CREATED,
155              fake_drive_service_helper_->AddOrphanedFolder(
156                  kSyncRootFolderTitle, &sync_root_folder_id_));
157    ASSERT_EQ(google_apis::HTTP_CREATED,
158              fake_drive_service_helper_->AddFolder(
159                  sync_root_folder_id_, kAppID, &app_root_folder_id_));
160    ASSERT_EQ(google_apis::HTTP_CREATED,
161              fake_drive_service_helper_->AddFolder(
162                  sync_root_folder_id_, kUnregisteredAppID,
163                  &unregistered_app_root_folder_id_));
164  }
165
166  void InitializeMetadataDatabase() {
167    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
168    SyncEngineInitializer* initializer =
169        new SyncEngineInitializer(
170            context_.get(),
171            base::MessageLoopProxy::current(),
172            database_dir_.path(),
173            in_memory_env_.get());
174
175    sync_task_manager_->ScheduleSyncTask(
176        FROM_HERE, scoped_ptr<SyncTask>(initializer),
177        SyncTaskManager::PRIORITY_MED,
178        base::Bind(&ListChangesTaskTest::DidInitializeMetadataDatabase,
179                   base::Unretained(this), initializer, &status));
180
181    base::RunLoop().RunUntilIdle();
182
183    EXPECT_EQ(SYNC_STATUS_OK, status);
184  }
185
186  void DidInitializeMetadataDatabase(SyncEngineInitializer* initializer,
187                                     SyncStatusCode* status_out,
188                                     SyncStatusCode status) {
189    context_->SetMetadataDatabase(initializer->PassMetadataDatabase());
190    *status_out = status;
191  }
192
193  void RegisterApp(const std::string& app_id) {
194    EXPECT_EQ(SYNC_STATUS_OK, RunTask(scoped_ptr<SyncTask>(
195        new RegisterAppTask(context_.get(), app_id))));
196  }
197
198  scoped_ptr<leveldb::Env> in_memory_env_;
199
200  std::string sync_root_folder_id_;
201  std::string app_root_folder_id_;
202  std::string unregistered_app_root_folder_id_;
203
204  content::TestBrowserThreadBundle browser_threads_;
205  base::ScopedTempDir database_dir_;
206
207  scoped_ptr<SyncEngineContext> context_;
208  scoped_ptr<FakeDriveServiceHelper> fake_drive_service_helper_;
209
210  scoped_ptr<SyncTaskManager> sync_task_manager_;
211
212  DISALLOW_COPY_AND_ASSIGN(ListChangesTaskTest);
213};
214
215TEST_F(ListChangesTaskTest, NoChange) {
216  size_t num_dirty_trackers = CountDirtyTracker();
217
218  EXPECT_EQ(SYNC_STATUS_NO_CHANGE_TO_SYNC, RunTask(
219      scoped_ptr<SyncTask>(new ListChangesTask(GetSyncEngineContext()))));
220
221  EXPECT_EQ(num_dirty_trackers, CountDirtyTracker());
222}
223
224TEST_F(ListChangesTaskTest, UnrelatedChange) {
225  size_t num_dirty_trackers = CountDirtyTracker();
226
227  SetUpChangesInFolder(root_resource_id());
228  SetUpChangesInFolder(unregistered_app_root_folder_id());
229
230  EXPECT_EQ(SYNC_STATUS_OK, RunTask(
231      scoped_ptr<SyncTask>(new ListChangesTask(GetSyncEngineContext()))));
232
233  EXPECT_EQ(num_dirty_trackers, CountDirtyTracker());
234}
235
236TEST_F(ListChangesTaskTest, UnderTrackedFolder) {
237  size_t num_dirty_trackers = CountDirtyTracker();
238
239  SetUpChangesInFolder(app_root_folder_id());
240
241  EXPECT_EQ(SYNC_STATUS_OK, RunTask(
242      scoped_ptr<SyncTask>(new ListChangesTask(GetSyncEngineContext()))));
243
244  EXPECT_EQ(num_dirty_trackers + 4, CountDirtyTracker());
245}
246
247}  // namespace drive_backend
248}  // namespace sync_file_system
249