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