src/chrome/browser/chromeos/drive/file_system/operation_test_base.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/chromeos/drive/file_system/operation_test_base.h"
   6
   7 #include "base/prefs/testing_pref_service.h"
   8 #include "base/threading/sequenced_worker_pool.h"
   9 #include "chrome/browser/chromeos/drive/change_list_loader.h"
  10 #include "chrome/browser/chromeos/drive/fake_free_disk_space_getter.h"
  11 #include "chrome/browser/chromeos/drive/file_cache.h"
  12 #include "chrome/browser/chromeos/drive/file_system/operation_observer.h"
  13 #include "chrome/browser/chromeos/drive/job_scheduler.h"
  14 #include "chrome/browser/chromeos/drive/resource_metadata.h"
  15 #include "chrome/browser/chromeos/drive/test_util.h"
  16 #include "chrome/browser/drive/event_logger.h"
  17 #include "chrome/browser/drive/fake_drive_service.h"
  18 #include "chrome/browser/drive/test_util.h"
  19 #include "content/public/browser/browser_thread.h"
  20 #include "google_apis/drive/test_util.h"
  21
  22 namespace drive {
  23 namespace file_system {
  24
  25 OperationTestBase::LoggingObserver::LoggingObserver() {
  26 }
  27
  28 OperationTestBase::LoggingObserver::~LoggingObserver() {
  29 }
  30
  31 void OperationTestBase::LoggingObserver::OnDirectoryChangedByOperation(
  32     const base::FilePath& path) {
  33   changed_paths_.insert(path);
  34 }
  35
  36 void OperationTestBase::LoggingObserver::OnEntryUpdatedByOperation(
  37     const std::string& local_id) {
  38   updated_local_ids_.insert(local_id);
  39 }
  40
  41 void OperationTestBase::LoggingObserver::OnDriveSyncError(
  42     DriveSyncErrorType type, const std::string& local_id) {
  43   drive_sync_errors_.push_back(type);
  44 }
  45
  46 OperationTestBase::OperationTestBase() {
  47 }
  48
  49 OperationTestBase::OperationTestBase(int test_thread_bundle_options)
  50     : thread_bundle_(test_thread_bundle_options) {
  51 }
  52
  53 OperationTestBase::~OperationTestBase() {
  54 }
  55
  56 void OperationTestBase::SetUp() {
  57   scoped_refptr<base::SequencedWorkerPool> pool =
  58       content::BrowserThread::GetBlockingPool();
  59   blocking_task_runner_ =
  60       pool->GetSequencedTaskRunner(pool->GetSequenceToken());
  61
  62   pref_service_.reset(new TestingPrefServiceSimple);
  63   test_util::RegisterDrivePrefs(pref_service_->registry());
  64
  65   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
  66
  67   logger_.reset(new EventLogger);
  68
  69   fake_drive_service_.reset(new FakeDriveService);
  70   ASSERT_TRUE(test_util::SetUpTestEntries(fake_drive_service_.get()));
  71
  72   scheduler_.reset(new JobScheduler(
  73       pref_service_.get(),
  74       logger_.get(),
  75       fake_drive_service_.get(),
  76       blocking_task_runner_.get()));
  77
  78   metadata_storage_.reset(new internal::ResourceMetadataStorage(
  79       temp_dir_.path(), blocking_task_runner_.get()));
  80   bool success = false;
  81   base::PostTaskAndReplyWithResult(
  82       blocking_task_runner_.get(),
  83       FROM_HERE,
  84       base::Bind(&internal::ResourceMetadataStorage::Initialize,
  85                  base::Unretained(metadata_storage_.get())),
  86       google_apis::test_util::CreateCopyResultCallback(&success));
  87   test_util::RunBlockingPoolTask();
  88   ASSERT_TRUE(success);
  89
  90   metadata_.reset(new internal::ResourceMetadata(metadata_storage_.get(),
  91                                                  blocking_task_runner_));
  92
  93   FileError error = FILE_ERROR_FAILED;
  94   base::PostTaskAndReplyWithResult(
  95       blocking_task_runner_.get(),
  96       FROM_HERE,
  97       base::Bind(&internal::ResourceMetadata::Initialize,
  98                  base::Unretained(metadata_.get())),
  99       google_apis::test_util::CreateCopyResultCallback(&error));
 100   test_util::RunBlockingPoolTask();
 101   ASSERT_EQ(FILE_ERROR_OK, error);
 102
 103   fake_free_disk_space_getter_.reset(new FakeFreeDiskSpaceGetter);
 104   cache_.reset(new internal::FileCache(metadata_storage_.get(),
 105                                        temp_dir_.path(),
 106                                        blocking_task_runner_.get(),
 107                                        fake_free_disk_space_getter_.get()));
 108   success = false;
 109   base::PostTaskAndReplyWithResult(
 110       blocking_task_runner_.get(),
 111       FROM_HERE,
 112       base::Bind(&internal::FileCache::Initialize,
 113                  base::Unretained(cache_.get())),
 114       google_apis::test_util::CreateCopyResultCallback(&success));
 115   test_util::RunBlockingPoolTask();
 116   ASSERT_TRUE(success);
 117
 118   // Makes sure the FakeDriveService's content is loaded to the metadata_.
 119   about_resource_loader_.reset(new internal::AboutResourceLoader(
 120       scheduler_.get()));
 121   loader_controller_.reset(new internal::LoaderController);
 122   change_list_loader_.reset(new internal::ChangeListLoader(
 123       logger_.get(),
 124       blocking_task_runner_.get(),
 125       metadata_.get(),
 126       scheduler_.get(),
 127       about_resource_loader_.get(),
 128       loader_controller_.get()));
 129   change_list_loader_->LoadIfNeeded(
 130       google_apis::test_util::CreateCopyResultCallback(&error));
 131   test_util::RunBlockingPoolTask();
 132   ASSERT_EQ(FILE_ERROR_OK, error);
 133 }
 134
 135 FileError OperationTestBase::GetLocalResourceEntry(const base::FilePath& path,
 136                                                    ResourceEntry* entry) {
 137   FileError error = FILE_ERROR_FAILED;
 138   base::PostTaskAndReplyWithResult(
 139       blocking_task_runner(),
 140       FROM_HERE,
 141       base::Bind(&internal::ResourceMetadata::GetResourceEntryByPath,
 142                  base::Unretained(metadata()), path, entry),
 143       base::Bind(google_apis::test_util::CreateCopyResultCallback(&error)));
 144   test_util::RunBlockingPoolTask();
 145   return error;
 146 }
 147
 148 FileError OperationTestBase::GetLocalResourceEntryById(
 149     const std::string& local_id,
 150     ResourceEntry* entry) {
 151   FileError error = FILE_ERROR_FAILED;
 152   base::PostTaskAndReplyWithResult(
 153       blocking_task_runner(),
 154       FROM_HERE,
 155       base::Bind(&internal::ResourceMetadata::GetResourceEntryById,
 156                  base::Unretained(metadata()), local_id, entry),
 157       base::Bind(google_apis::test_util::CreateCopyResultCallback(&error)));
 158   test_util::RunBlockingPoolTask();
 159   return error;
 160 }
 161
 162 std::string OperationTestBase::GetLocalId(const base::FilePath& path) {
 163   std::string local_id;
 164   FileError error = FILE_ERROR_FAILED;
 165   base::PostTaskAndReplyWithResult(
 166       blocking_task_runner(),
 167       FROM_HERE,
 168       base::Bind(&internal::ResourceMetadata::GetIdByPath,
 169                  base::Unretained(metadata()), path, &local_id),
 170       base::Bind(google_apis::test_util::CreateCopyResultCallback(&error)));
 171   test_util::RunBlockingPoolTask();
 172   EXPECT_EQ(FILE_ERROR_OK, error) << path.value();
 173   return local_id;
 174 }
 175
 176 FileError OperationTestBase::CheckForUpdates() {
 177   FileError error = FILE_ERROR_FAILED;
 178   change_list_loader_->CheckForUpdates(
 179       google_apis::test_util::CreateCopyResultCallback(&error));
 180   test_util::RunBlockingPoolTask();
 181   return error;
 182 }
 183
 184 }  // namespace file_system
 185 }  // namespace drive