list_changes_task_unittest.cc revision cedac228d2dd51db4b79ea1e72c7f249408ee061 
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        NULL,
67        base::MessageLoopProxy::current(),
68        base::MessageLoopProxy::current(),
69        base::MessageLoopProxy::current()));
70
71    SetUpRemoteFolders();
72
73    InitializeMetadataDatabase();
74    RegisterApp(kAppID);
75  }
76
77  virtual void TearDown() OVERRIDE {
78    sync_task_manager_.reset();
79    context_.reset();
80    base::RunLoop().RunUntilIdle();
81  }
82
83 protected:
84  SyncStatusCode RunTask(scoped_ptr<SyncTask> sync_task) {
85    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
86    sync_task_manager_->ScheduleSyncTask(
87        FROM_HERE, sync_task.Pass(),
88        SyncTaskManager::PRIORITY_MED,
89        CreateResultReceiver(&status));
90    base::RunLoop().RunUntilIdle();
91    return status;
92  }
93
94  size_t CountDirtyTracker() {
95    return context_->GetMetadataDatabase()->CountDirtyTracker();
96  }
97
98  FakeDriveServiceHelper* fake_drive_service_helper() {
99    return fake_drive_service_helper_.get();
100  }
101
102  void SetUpChangesInFolder(const std::string& folder_id) {
103    std::string new_file_id;
104    ASSERT_EQ(google_apis::HTTP_SUCCESS,
105              fake_drive_service_helper()->AddFile(
106                  folder_id, "new file", "file contents", &new_file_id));
107    std::string same_name_file_id;
108    ASSERT_EQ(google_apis::HTTP_SUCCESS,
109              fake_drive_service_helper()->AddFile(
110                  folder_id, "new file", "file contents",
111                  &same_name_file_id));
112
113    std::string new_folder_id;
114    ASSERT_EQ(google_apis::HTTP_CREATED,
115              fake_drive_service_helper()->AddFolder(
116                  folder_id, "new folder", &new_folder_id));
117
118    std::string modified_file_id;
119    ASSERT_EQ(google_apis::HTTP_SUCCESS,
120              fake_drive_service_helper()->AddFile(
121                  folder_id, "modified file", "file content",
122                  &modified_file_id));
123    ASSERT_EQ(google_apis::HTTP_SUCCESS,
124              fake_drive_service_helper()->UpdateFile(
125                  modified_file_id, "modified file content"));
126
127
128    std::string deleted_file_id;
129    ASSERT_EQ(google_apis::HTTP_SUCCESS,
130              fake_drive_service_helper()->AddFile(
131                  folder_id, "trashed file", "file content",
132                  &deleted_file_id));
133    ASSERT_EQ(google_apis::HTTP_NO_CONTENT,
134              fake_drive_service_helper()->DeleteResource(deleted_file_id));
135  }
136
137  std::string root_resource_id() {
138    return context_->GetDriveService()->GetRootResourceId();
139  }
140
141  std::string app_root_folder_id() {
142    return app_root_folder_id_;
143  }
144
145  std::string unregistered_app_root_folder_id() {
146    return unregistered_app_root_folder_id_;
147  }
148
149  SyncEngineContext* GetSyncEngineContext() {
150    return context_.get();
151  }
152
153 private:
154  void SetUpRemoteFolders() {
155    ASSERT_EQ(google_apis::HTTP_CREATED,
156              fake_drive_service_helper_->AddOrphanedFolder(
157                  kSyncRootFolderTitle, &sync_root_folder_id_));
158    ASSERT_EQ(google_apis::HTTP_CREATED,
159              fake_drive_service_helper_->AddFolder(
160                  sync_root_folder_id_, kAppID, &app_root_folder_id_));
161    ASSERT_EQ(google_apis::HTTP_CREATED,
162              fake_drive_service_helper_->AddFolder(
163                  sync_root_folder_id_, kUnregisteredAppID,
164                  &unregistered_app_root_folder_id_));
165  }
166
167  void InitializeMetadataDatabase() {
168    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
169    SyncEngineInitializer* initializer =
170        new SyncEngineInitializer(context_.get(),
171                                  database_dir_.path(),
172                                  in_memory_env_.get());
173
174    sync_task_manager_->ScheduleSyncTask(
175        FROM_HERE, scoped_ptr<SyncTask>(initializer),
176        SyncTaskManager::PRIORITY_MED,
177        base::Bind(&ListChangesTaskTest::DidInitializeMetadataDatabase,
178                   base::Unretained(this), initializer, &status));
179
180    base::RunLoop().RunUntilIdle();
181
182    EXPECT_EQ(SYNC_STATUS_OK, status);
183  }
184
185  void DidInitializeMetadataDatabase(SyncEngineInitializer* initializer,
186                                     SyncStatusCode* status_out,
187                                     SyncStatusCode status) {
188    context_->SetMetadataDatabase(initializer->PassMetadataDatabase());
189    *status_out = status;
190  }
191
192  void RegisterApp(const std::string& app_id) {
193    EXPECT_EQ(SYNC_STATUS_OK, RunTask(scoped_ptr<SyncTask>(
194        new RegisterAppTask(context_.get(), app_id))));
195  }
196
197  scoped_ptr<leveldb::Env> in_memory_env_;
198
199  std::string sync_root_folder_id_;
200  std::string app_root_folder_id_;
201  std::string unregistered_app_root_folder_id_;
202
203  content::TestBrowserThreadBundle browser_threads_;
204  base::ScopedTempDir database_dir_;
205
206  scoped_ptr<SyncEngineContext> context_;
207  scoped_ptr<FakeDriveServiceHelper> fake_drive_service_helper_;
208
209  scoped_ptr<SyncTaskManager> sync_task_manager_;
210
211  DISALLOW_COPY_AND_ASSIGN(ListChangesTaskTest);
212};
213
214TEST_F(ListChangesTaskTest, NoChange) {
215  size_t num_dirty_trackers = CountDirtyTracker();
216
217  EXPECT_EQ(SYNC_STATUS_NO_CHANGE_TO_SYNC, RunTask(
218      scoped_ptr<SyncTask>(new ListChangesTask(GetSyncEngineContext()))));
219
220  EXPECT_EQ(num_dirty_trackers, CountDirtyTracker());
221}
222
223TEST_F(ListChangesTaskTest, UnrelatedChange) {
224  size_t num_dirty_trackers = CountDirtyTracker();
225
226  SetUpChangesInFolder(root_resource_id());
227  SetUpChangesInFolder(unregistered_app_root_folder_id());
228
229  EXPECT_EQ(SYNC_STATUS_OK, RunTask(
230      scoped_ptr<SyncTask>(new ListChangesTask(GetSyncEngineContext()))));
231
232  EXPECT_EQ(num_dirty_trackers, CountDirtyTracker());
233}
234
235TEST_F(ListChangesTaskTest, UnderTrackedFolder) {
236  size_t num_dirty_trackers = CountDirtyTracker();
237
238  SetUpChangesInFolder(app_root_folder_id());
239
240  EXPECT_EQ(SYNC_STATUS_OK, RunTask(
241      scoped_ptr<SyncTask>(new ListChangesTask(GetSyncEngineContext()))));
242
243  EXPECT_EQ(num_dirty_trackers + 4, CountDirtyTracker());
244}
245
246}  // namespace drive_backend
247}  // namespace sync_file_system
248