1// Copyright 2014 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/sync_worker.h"
6
7#include "base/files/scoped_temp_dir.h"
8#include "base/run_loop.h"
9#include "base/strings/stringprintf.h"
10#include "base/thread_task_runner_handle.h"
11#include "chrome/browser/drive/drive_uploader.h"
12#include "chrome/browser/drive/fake_drive_service.h"
13#include "chrome/browser/extensions/test_extension_service.h"
14#include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
15#include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
16#include "chrome/browser/sync_file_system/drive_backend/sync_engine_context.h"
17#include "chrome/browser/sync_file_system/drive_backend/sync_task.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 "extensions/common/extension.h"
22#include "extensions/common/extension_builder.h"
23#include "extensions/common/extension_set.h"
24#include "extensions/common/value_builder.h"
25#include "testing/gtest/include/gtest/gtest.h"
26#include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
27#include "third_party/leveldatabase/src/include/leveldb/env.h"
28
29namespace sync_file_system {
30namespace drive_backend {
31
32namespace {
33
34const char kAppID[] = "app_id";
35
36void EmptyTask(SyncStatusCode status, const SyncStatusCallback& callback) {
37  base::MessageLoop::current()->PostTask(
38      FROM_HERE, base::Bind(callback, status));
39}
40
41}  // namespace
42
43class MockSyncTask : public ExclusiveTask {
44 public:
45  explicit MockSyncTask(bool used_network) {
46    set_used_network(used_network);
47  }
48  virtual ~MockSyncTask() {}
49
50  virtual void RunExclusive(const SyncStatusCallback& callback) OVERRIDE {
51    callback.Run(SYNC_STATUS_OK);
52  }
53
54 private:
55  DISALLOW_COPY_AND_ASSIGN(MockSyncTask);
56};
57
58class MockExtensionService : public TestExtensionService {
59 public:
60  MockExtensionService() {}
61  virtual ~MockExtensionService() {}
62
63  virtual const extensions::ExtensionSet* extensions() const OVERRIDE {
64    return &extensions_;
65  }
66
67  virtual void AddExtension(const extensions::Extension* extension) OVERRIDE {
68    extensions_.Insert(make_scoped_refptr(extension));
69  }
70
71  virtual const extensions::Extension* GetInstalledExtension(
72      const std::string& extension_id) const OVERRIDE {
73    return extensions_.GetByID(extension_id);
74  }
75
76  virtual bool IsExtensionEnabled(
77      const std::string& extension_id) const OVERRIDE {
78    return extensions_.Contains(extension_id) &&
79        !disabled_extensions_.Contains(extension_id);
80  }
81
82  void UninstallExtension(const std::string& extension_id) {
83    extensions_.Remove(extension_id);
84    disabled_extensions_.Remove(extension_id);
85  }
86
87  void DisableExtension(const std::string& extension_id) {
88    if (!IsExtensionEnabled(extension_id))
89      return;
90    const extensions::Extension* extension = extensions_.GetByID(extension_id);
91    disabled_extensions_.Insert(make_scoped_refptr(extension));
92  }
93
94 private:
95  extensions::ExtensionSet extensions_;
96  extensions::ExtensionSet disabled_extensions_;
97
98  DISALLOW_COPY_AND_ASSIGN(MockExtensionService);
99};
100
101class SyncWorkerTest : public testing::Test,
102                       public base::SupportsWeakPtr<SyncWorkerTest> {
103 public:
104  SyncWorkerTest() {}
105  virtual ~SyncWorkerTest() {}
106
107  virtual void SetUp() OVERRIDE {
108    ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
109    in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
110
111    extension_service_.reset(new MockExtensionService);
112    scoped_ptr<drive::DriveServiceInterface>
113        fake_drive_service(new drive::FakeDriveService);
114
115    scoped_ptr<SyncEngineContext>
116        sync_engine_context(new SyncEngineContext(
117            fake_drive_service.Pass(),
118            scoped_ptr<drive::DriveUploaderInterface>(),
119            NULL /* task_logger */,
120            base::ThreadTaskRunnerHandle::Get() /* ui_task_runner */,
121            base::ThreadTaskRunnerHandle::Get() /* worker_task_runner */));
122
123    sync_worker_.reset(new SyncWorker(
124        profile_dir_.path(),
125        extension_service_->AsWeakPtr(),
126        in_memory_env_.get()));
127    sync_worker_->Initialize(sync_engine_context.Pass());
128
129    sync_worker_->SetSyncEnabled(true);
130    base::RunLoop().RunUntilIdle();
131  }
132
133  virtual void TearDown() OVERRIDE {
134    sync_worker_.reset();
135    extension_service_.reset();
136    base::RunLoop().RunUntilIdle();
137  }
138
139  MockExtensionService* extension_service() { return extension_service_.get(); }
140  SyncWorker* sync_worker() { return sync_worker_.get(); }
141
142  void UpdateRegisteredApps() {
143    sync_worker_->UpdateRegisteredApps();
144  }
145
146  SyncTaskManager* GetSyncTaskManager() {
147    return sync_worker_->task_manager_.get();
148  }
149
150  void CheckServiceState(SyncStatusCode expected_sync_status,
151                         RemoteServiceState expected_service_status,
152                         SyncStatusCode sync_status) {
153    EXPECT_EQ(expected_sync_status, sync_status);
154    EXPECT_EQ(expected_service_status, sync_worker_->GetCurrentState());
155  }
156
157  MetadataDatabase* metadata_database() {
158    return sync_worker_->GetMetadataDatabase();
159  }
160
161 private:
162  content::TestBrowserThreadBundle browser_threads_;
163  base::ScopedTempDir profile_dir_;
164  scoped_ptr<leveldb::Env> in_memory_env_;
165
166  scoped_ptr<MockExtensionService> extension_service_;
167  scoped_ptr<SyncWorker> sync_worker_;
168
169  DISALLOW_COPY_AND_ASSIGN(SyncWorkerTest);
170};
171
172TEST_F(SyncWorkerTest, EnableOrigin) {
173  FileTracker tracker;
174  SyncStatusCode sync_status = SYNC_STATUS_UNKNOWN;
175  GURL origin = extensions::Extension::GetBaseURLFromExtensionId(kAppID);
176
177  sync_worker()->RegisterOrigin(origin, CreateResultReceiver(&sync_status));
178  base::RunLoop().RunUntilIdle();
179  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
180  ASSERT_TRUE(metadata_database()->FindAppRootTracker(kAppID, &tracker));
181  EXPECT_EQ(TRACKER_KIND_APP_ROOT, tracker.tracker_kind());
182
183  sync_worker()->DisableOrigin(origin, CreateResultReceiver(&sync_status));
184  base::RunLoop().RunUntilIdle();
185  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
186  ASSERT_TRUE(metadata_database()->FindAppRootTracker(kAppID, &tracker));
187  EXPECT_EQ(TRACKER_KIND_DISABLED_APP_ROOT, tracker.tracker_kind());
188
189  sync_worker()->EnableOrigin(origin, CreateResultReceiver(&sync_status));
190  base::RunLoop().RunUntilIdle();
191  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
192  ASSERT_TRUE(metadata_database()->FindAppRootTracker(kAppID, &tracker));
193  EXPECT_EQ(TRACKER_KIND_APP_ROOT, tracker.tracker_kind());
194
195  sync_worker()->UninstallOrigin(
196      origin,
197      RemoteFileSyncService::UNINSTALL_AND_KEEP_REMOTE,
198      CreateResultReceiver(&sync_status));
199  base::RunLoop().RunUntilIdle();
200  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
201  ASSERT_FALSE(metadata_database()->FindAppRootTracker(kAppID, &tracker));
202}
203
204TEST_F(SyncWorkerTest, UpdateRegisteredApps) {
205  SyncStatusCode sync_status = SYNC_STATUS_UNKNOWN;
206  for (int i = 0; i < 3; i++) {
207    scoped_refptr<const extensions::Extension> extension =
208        extensions::ExtensionBuilder()
209        .SetManifest(extensions::DictionaryBuilder()
210                     .Set("name", "foo")
211                     .Set("version", "1.0")
212                     .Set("manifest_version", 2))
213        .SetID(base::StringPrintf("app_%d", i))
214        .Build();
215    extension_service()->AddExtension(extension.get());
216    GURL origin = extensions::Extension::GetBaseURLFromExtensionId(
217        extension->id());
218    sync_status = SYNC_STATUS_UNKNOWN;
219    sync_worker()->RegisterOrigin(origin, CreateResultReceiver(&sync_status));
220    base::RunLoop().RunUntilIdle();
221    EXPECT_EQ(SYNC_STATUS_OK, sync_status);
222  }
223
224  FileTracker tracker;
225
226  ASSERT_TRUE(metadata_database()->FindAppRootTracker("app_0", &tracker));
227  EXPECT_EQ(TRACKER_KIND_APP_ROOT, tracker.tracker_kind());
228
229  ASSERT_TRUE(metadata_database()->FindAppRootTracker("app_1", &tracker));
230  EXPECT_EQ(TRACKER_KIND_APP_ROOT, tracker.tracker_kind());
231
232  ASSERT_TRUE(metadata_database()->FindAppRootTracker("app_2", &tracker));
233  EXPECT_EQ(TRACKER_KIND_APP_ROOT, tracker.tracker_kind());
234
235  extension_service()->DisableExtension("app_1");
236  extension_service()->UninstallExtension("app_2");
237  ASSERT_FALSE(extension_service()->GetInstalledExtension("app_2"));
238  UpdateRegisteredApps();
239  base::RunLoop().RunUntilIdle();
240
241  ASSERT_TRUE(metadata_database()->FindAppRootTracker("app_0", &tracker));
242  EXPECT_EQ(TRACKER_KIND_APP_ROOT, tracker.tracker_kind());
243
244  ASSERT_TRUE(metadata_database()->FindAppRootTracker("app_1", &tracker));
245  EXPECT_EQ(TRACKER_KIND_DISABLED_APP_ROOT, tracker.tracker_kind());
246
247  ASSERT_FALSE(metadata_database()->FindAppRootTracker("app_2", &tracker));
248}
249
250TEST_F(SyncWorkerTest, GetOriginStatusMap) {
251  FileTracker tracker;
252  SyncStatusCode sync_status = SYNC_STATUS_UNKNOWN;
253  GURL origin = extensions::Extension::GetBaseURLFromExtensionId(kAppID);
254
255  sync_worker()->RegisterOrigin(GURL("chrome-extension://app_0"),
256                                CreateResultReceiver(&sync_status));
257  base::RunLoop().RunUntilIdle();
258  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
259
260  sync_worker()->RegisterOrigin(GURL("chrome-extension://app_1"),
261                                CreateResultReceiver(&sync_status));
262  base::RunLoop().RunUntilIdle();
263  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
264
265  scoped_ptr<RemoteFileSyncService::OriginStatusMap> status_map;
266  sync_worker()->GetOriginStatusMap(CreateResultReceiver(&status_map));
267  base::RunLoop().RunUntilIdle();
268  ASSERT_EQ(2u, status_map->size());
269  EXPECT_EQ("Enabled", (*status_map)[GURL("chrome-extension://app_0")]);
270  EXPECT_EQ("Enabled", (*status_map)[GURL("chrome-extension://app_1")]);
271
272  sync_worker()->DisableOrigin(GURL("chrome-extension://app_1"),
273                               CreateResultReceiver(&sync_status));
274  base::RunLoop().RunUntilIdle();
275  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
276
277  sync_worker()->GetOriginStatusMap(CreateResultReceiver(&status_map));
278  base::RunLoop().RunUntilIdle();
279  ASSERT_EQ(2u, status_map->size());
280  EXPECT_EQ("Enabled", (*status_map)[GURL("chrome-extension://app_0")]);
281  EXPECT_EQ("Disabled", (*status_map)[GURL("chrome-extension://app_1")]);
282}
283
284TEST_F(SyncWorkerTest, UpdateServiceState) {
285  EXPECT_EQ(REMOTE_SERVICE_OK, sync_worker()->GetCurrentState());
286
287  GetSyncTaskManager()->ScheduleTask(
288      FROM_HERE,
289      base::Bind(&EmptyTask, SYNC_STATUS_AUTHENTICATION_FAILED),
290      SyncTaskManager::PRIORITY_MED,
291      base::Bind(&SyncWorkerTest::CheckServiceState,
292                 AsWeakPtr(),
293                 SYNC_STATUS_AUTHENTICATION_FAILED,
294                 REMOTE_SERVICE_AUTHENTICATION_REQUIRED));
295
296  GetSyncTaskManager()->ScheduleTask(
297      FROM_HERE,
298      base::Bind(&EmptyTask, SYNC_STATUS_ACCESS_FORBIDDEN),
299      SyncTaskManager::PRIORITY_MED,
300      base::Bind(&SyncWorkerTest::CheckServiceState,
301                 AsWeakPtr(),
302                 SYNC_STATUS_ACCESS_FORBIDDEN,
303                 REMOTE_SERVICE_ACCESS_FORBIDDEN));
304
305  GetSyncTaskManager()->ScheduleTask(
306      FROM_HERE,
307      base::Bind(&EmptyTask, SYNC_STATUS_SERVICE_TEMPORARILY_UNAVAILABLE),
308      SyncTaskManager::PRIORITY_MED,
309      base::Bind(&SyncWorkerTest::CheckServiceState,
310                 AsWeakPtr(),
311                 SYNC_STATUS_SERVICE_TEMPORARILY_UNAVAILABLE,
312                 REMOTE_SERVICE_TEMPORARY_UNAVAILABLE));
313
314  GetSyncTaskManager()->ScheduleTask(
315      FROM_HERE,
316      base::Bind(&EmptyTask, SYNC_STATUS_NETWORK_ERROR),
317      SyncTaskManager::PRIORITY_MED,
318      base::Bind(&SyncWorkerTest::CheckServiceState,
319                 AsWeakPtr(),
320                 SYNC_STATUS_NETWORK_ERROR,
321                 REMOTE_SERVICE_TEMPORARY_UNAVAILABLE));
322
323  GetSyncTaskManager()->ScheduleTask(
324      FROM_HERE,
325      base::Bind(&EmptyTask, SYNC_STATUS_ABORT),
326      SyncTaskManager::PRIORITY_MED,
327      base::Bind(&SyncWorkerTest::CheckServiceState,
328                 AsWeakPtr(),
329                 SYNC_STATUS_ABORT,
330                 REMOTE_SERVICE_TEMPORARY_UNAVAILABLE));
331
332  GetSyncTaskManager()->ScheduleTask(
333      FROM_HERE,
334      base::Bind(&EmptyTask, SYNC_STATUS_FAILED),
335      SyncTaskManager::PRIORITY_MED,
336      base::Bind(&SyncWorkerTest::CheckServiceState,
337                 AsWeakPtr(),
338                 SYNC_STATUS_FAILED,
339                 REMOTE_SERVICE_TEMPORARY_UNAVAILABLE));
340
341  GetSyncTaskManager()->ScheduleTask(
342      FROM_HERE,
343      base::Bind(&EmptyTask, SYNC_DATABASE_ERROR_CORRUPTION),
344      SyncTaskManager::PRIORITY_MED,
345      base::Bind(&SyncWorkerTest::CheckServiceState,
346                 AsWeakPtr(),
347                 SYNC_DATABASE_ERROR_CORRUPTION,
348                 REMOTE_SERVICE_DISABLED));
349
350  GetSyncTaskManager()->ScheduleTask(
351      FROM_HERE,
352      base::Bind(&EmptyTask, SYNC_DATABASE_ERROR_IO_ERROR),
353      SyncTaskManager::PRIORITY_MED,
354      base::Bind(&SyncWorkerTest::CheckServiceState,
355                 AsWeakPtr(),
356                 SYNC_DATABASE_ERROR_IO_ERROR,
357                 REMOTE_SERVICE_DISABLED));
358
359  GetSyncTaskManager()->ScheduleTask(
360      FROM_HERE,
361      base::Bind(&EmptyTask, SYNC_DATABASE_ERROR_FAILED),
362      SyncTaskManager::PRIORITY_MED,
363      base::Bind(&SyncWorkerTest::CheckServiceState,
364                 AsWeakPtr(),
365                 SYNC_DATABASE_ERROR_FAILED,
366                 REMOTE_SERVICE_DISABLED));
367
368  GetSyncTaskManager()->ScheduleSyncTask(
369      FROM_HERE,
370      scoped_ptr<SyncTask>(new MockSyncTask(false)),
371      SyncTaskManager::PRIORITY_MED,
372      base::Bind(&SyncWorkerTest::CheckServiceState,
373                 AsWeakPtr(),
374                 SYNC_STATUS_OK,
375                 REMOTE_SERVICE_DISABLED));
376
377  GetSyncTaskManager()->ScheduleSyncTask(
378      FROM_HERE,
379      scoped_ptr<SyncTask>(new MockSyncTask(true)),
380      SyncTaskManager::PRIORITY_MED,
381      base::Bind(&SyncWorkerTest::CheckServiceState,
382                 AsWeakPtr(),
383                 SYNC_STATUS_OK,
384                 REMOTE_SERVICE_OK));
385
386  base::RunLoop().RunUntilIdle();
387}
388
389}  // namespace drive_backend
390}  // namespace sync_file_system
391