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