src/chrome/browser/sync_file_system/drive_backend/list_changes_task_unittest.cc

   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 "base/files/scoped_temp_dir.h"
   8 #include "base/format_macros.h"
   9 #include "base/run_loop.h"
  10 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
  11 #include "chrome/browser/sync_file_system/drive_backend/fake_drive_service_helper.h"
  12 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
  13 #include "chrome/browser/sync_file_system/drive_backend/register_app_task.h"
  14 #include "chrome/browser/sync_file_system/drive_backend/sync_engine_context.h"
  15 #include "chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.h"
  16 #include "chrome/browser/sync_file_system/sync_file_system_test_util.h"
  17 #include "content/public/test/test_browser_thread_bundle.h"
  18 #include "google_apis/drive/drive_api_parser.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20 #include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
  21 #include "third_party/leveldatabase/src/include/leveldb/env.h"
  22
  23 namespace sync_file_system {
  24 namespace drive_backend {
  25
  26 namespace {
  27
  28 const char kAppID[] = "app_id";
  29 const char kUnregisteredAppID[] = "app_id unregistered";
  30
  31 }  // namespace
  32
  33 class ListChangesTaskTest : public testing::Test,
  34                             public SyncEngineContext {
  35  public:
  36   ListChangesTaskTest() {}
  37   virtual ~ListChangesTaskTest() {}
  38
  39   virtual void SetUp() OVERRIDE {
  40     ASSERT_TRUE(database_dir_.CreateUniqueTempDir());
  41     in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
  42
  43     fake_drive_service_.reset(new drive::FakeDriveService);
  44     ASSERT_TRUE(fake_drive_service_->LoadAccountMetadataForWapi(
  45         "sync_file_system/account_metadata.json"));
  46     ASSERT_TRUE(fake_drive_service_->LoadResourceListForWapi(
  47         "gdata/empty_feed.json"));
  48
  49     drive_uploader_.reset(new drive::DriveUploader(
  50         fake_drive_service_.get(), base::MessageLoopProxy::current()));
  51
  52     fake_drive_service_helper_.reset(new FakeDriveServiceHelper(
  53         fake_drive_service_.get(), drive_uploader_.get(),
  54         kSyncRootFolderTitle));
  55
  56     SetUpRemoteFolders();
  57     InitializeMetadataDatabase();
  58     RegisterApp(kAppID);
  59   }
  60
  61   virtual void TearDown() OVERRIDE {
  62     metadata_database_.reset();
  63     base::RunLoop().RunUntilIdle();
  64   }
  65
  66   virtual drive::DriveServiceInterface* GetDriveService() OVERRIDE {
  67     return fake_drive_service_.get();
  68   }
  69
  70   virtual drive::DriveUploader* GetDriveUploader() OVERRIDE {
  71     return NULL;
  72   }
  73
  74   virtual MetadataDatabase* GetMetadataDatabase() OVERRIDE {
  75     return metadata_database_.get();
  76   }
  77
  78   virtual RemoteChangeProcessor* GetRemoteChangeProcessor() OVERRIDE {
  79     return NULL;
  80   }
  81
  82   virtual base::SequencedTaskRunner* GetBlockingTaskRunner() OVERRIDE {
  83     return base::MessageLoopProxy::current();
  84   }
  85
  86  protected:
  87   SyncStatusCode RunTask(SyncTask* sync_task) {
  88     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
  89     sync_task->Run(CreateResultReceiver(&status));
  90     base::RunLoop().RunUntilIdle();
  91     return status;
  92   }
  93
  94   size_t CountDirtyTracker() {
  95     return metadata_database_->dirty_trackers_.size();
  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 fake_drive_service_->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  private:
 150   void SetUpRemoteFolders() {
 151     ASSERT_EQ(google_apis::HTTP_CREATED,
 152               fake_drive_service_helper_->AddOrphanedFolder(
 153                   kSyncRootFolderTitle, &sync_root_folder_id_));
 154     ASSERT_EQ(google_apis::HTTP_CREATED,
 155               fake_drive_service_helper_->AddFolder(
 156                   sync_root_folder_id_, kAppID, &app_root_folder_id_));
 157     ASSERT_EQ(google_apis::HTTP_CREATED,
 158               fake_drive_service_helper_->AddFolder(
 159                   sync_root_folder_id_, kUnregisteredAppID,
 160                   &unregistered_app_root_folder_id_));
 161   }
 162
 163   void InitializeMetadataDatabase() {
 164     SyncEngineInitializer initializer(this,
 165                                       base::MessageLoopProxy::current(),
 166                                       fake_drive_service_.get(),
 167                                       database_dir_.path(),
 168                                       in_memory_env_.get());
 169     EXPECT_EQ(SYNC_STATUS_OK, RunTask(&initializer));
 170     metadata_database_ = initializer.PassMetadataDatabase();
 171   }
 172
 173   void RegisterApp(const std::string& app_id) {
 174     RegisterAppTask register_app(this, app_id);
 175     EXPECT_EQ(SYNC_STATUS_OK, RunTask(&register_app));
 176   }
 177
 178   scoped_ptr<leveldb::Env> in_memory_env_;
 179
 180   std::string sync_root_folder_id_;
 181   std::string app_root_folder_id_;
 182   std::string unregistered_app_root_folder_id_;
 183
 184   content::TestBrowserThreadBundle browser_threads_;
 185   base::ScopedTempDir database_dir_;
 186
 187   scoped_ptr<drive::FakeDriveService> fake_drive_service_;
 188   scoped_ptr<drive::DriveUploader> drive_uploader_;
 189   scoped_ptr<FakeDriveServiceHelper> fake_drive_service_helper_;
 190
 191   scoped_ptr<MetadataDatabase> metadata_database_;
 192
 193   DISALLOW_COPY_AND_ASSIGN(ListChangesTaskTest);
 194 };
 195
 196 TEST_F(ListChangesTaskTest, NoChange) {
 197   size_t num_dirty_trackers = CountDirtyTracker();
 198
 199   ListChangesTask list_changes(this);
 200   EXPECT_EQ(SYNC_STATUS_NO_CHANGE_TO_SYNC, RunTask(&list_changes));
 201
 202   EXPECT_EQ(num_dirty_trackers, CountDirtyTracker());
 203 }
 204
 205 TEST_F(ListChangesTaskTest, UnrelatedChange) {
 206   size_t num_dirty_trackers = CountDirtyTracker();
 207
 208   SetUpChangesInFolder(root_resource_id());
 209   SetUpChangesInFolder(unregistered_app_root_folder_id());
 210
 211   ListChangesTask list_changes(this);
 212   EXPECT_EQ(SYNC_STATUS_OK, RunTask(&list_changes));
 213
 214   EXPECT_EQ(num_dirty_trackers, CountDirtyTracker());
 215 }
 216
 217 TEST_F(ListChangesTaskTest, UnderTrackedFolder) {
 218   size_t num_dirty_trackers = CountDirtyTracker();
 219
 220   SetUpChangesInFolder(app_root_folder_id());
 221
 222   ListChangesTask list_changes(this);
 223   EXPECT_EQ(SYNC_STATUS_OK, RunTask(&list_changes));
 224
 225   EXPECT_EQ(num_dirty_trackers + 4, CountDirtyTracker());
 226 }
 227
 228 }  // namespace drive_backend
 229 }  // namespace sync_file_system