sync_engine_unittest.cc revision 116680a4aac90f2aa7413d9095a592090648e557 
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/sync_engine.h"
6
7#include "base/files/scoped_temp_dir.h"
8#include "base/macros.h"
9#include "base/run_loop.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/sync_file_system/drive_backend/callback_helper.h"
14#include "chrome/browser/sync_file_system/drive_backend/fake_sync_worker.h"
15#include "chrome/browser/sync_file_system/drive_backend/sync_worker_interface.h"
16#include "chrome/browser/sync_file_system/remote_file_sync_service.h"
17#include "chrome/browser/sync_file_system/sync_file_system_test_util.h"
18#include "content/public/browser/browser_thread.h"
19#include "content/public/test/test_browser_thread_bundle.h"
20#include "testing/gtest/include/gtest/gtest.h"
21
22namespace sync_file_system {
23namespace drive_backend {
24
25class SyncEngineTest : public testing::Test,
26                       public base::SupportsWeakPtr<SyncEngineTest> {
27 public:
28  typedef RemoteFileSyncService::OriginStatusMap RemoteOriginStatusMap;
29
30  SyncEngineTest() {}
31  virtual ~SyncEngineTest() {}
32
33  virtual void SetUp() OVERRIDE {
34    ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
35
36    scoped_ptr<drive::DriveServiceInterface>
37        fake_drive_service(new drive::FakeDriveService);
38
39    worker_pool_ = new base::SequencedWorkerPool(1, "Worker");
40    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner =
41        base::ThreadTaskRunnerHandle::Get();
42    worker_task_runner_ =
43        worker_pool_->GetSequencedTaskRunnerWithShutdownBehavior(
44            worker_pool_->GetSequenceToken(),
45            base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
46
47    sync_engine_.reset(new drive_backend::SyncEngine(
48        ui_task_runner,
49        worker_task_runner_,
50        NULL /* file_task_runner */,
51        NULL /* drive_task_runner */,
52        profile_dir_.path(),
53        NULL /* task_logger */,
54        NULL /* notification_manager */,
55        NULL /* extension_service */,
56        NULL /* signin_manager */,
57        NULL /* token_service */,
58        NULL /* request_context */,
59        NULL /* in_memory_env */));
60
61    sync_engine_->InitializeForTesting(
62        fake_drive_service.Pass(),
63        scoped_ptr<drive::DriveUploaderInterface>(),
64        scoped_ptr<SyncWorkerInterface>(new FakeSyncWorker));
65    sync_engine_->SetSyncEnabled(true);
66
67    WaitForWorkerTaskRunner();
68  }
69
70  virtual void TearDown() OVERRIDE {
71    sync_engine_.reset();
72    WaitForWorkerTaskRunner();
73    worker_pool_->Shutdown();
74    base::RunLoop().RunUntilIdle();
75  }
76
77  bool FindOriginStatus(const GURL& origin, std::string* status) {
78    scoped_ptr<RemoteOriginStatusMap> status_map;
79    sync_engine()->GetOriginStatusMap(CreateResultReceiver(&status_map));
80    WaitForWorkerTaskRunner();
81
82    RemoteOriginStatusMap::const_iterator itr = status_map->find(origin);
83    if (itr == status_map->end())
84      return false;
85
86    *status = itr->second;
87    // If an origin is uninstalled, it should not be found actually.
88    if (*status == "Uninstalled")
89      return false;
90    return true;
91  }
92
93  void PostUpdateServiceState(RemoteServiceState state,
94                              const std::string& description) {
95    worker_task_runner_->PostTask(
96        FROM_HERE,
97        base::Bind(&FakeSyncWorker::UpdateServiceState,
98                   base::Unretained(fake_sync_worker()),
99                   state,
100                   description));
101    WaitForWorkerTaskRunner();
102  }
103
104  void WaitForWorkerTaskRunner() {
105    DCHECK(worker_task_runner_);
106
107    base::RunLoop run_loop;
108    worker_task_runner_->PostTask(
109        FROM_HERE,
110        RelayCallbackToCurrentThread(
111            FROM_HERE, run_loop.QuitClosure()));
112    run_loop.Run();
113  }
114
115  // Accessors
116  SyncEngine* sync_engine() { return sync_engine_.get(); }
117
118  FakeSyncWorker* fake_sync_worker() {
119    return static_cast<FakeSyncWorker*>(sync_engine_->sync_worker_.get());
120  }
121
122 private:
123  content::TestBrowserThreadBundle browser_threads_;
124  base::ScopedTempDir profile_dir_;
125  scoped_ptr<drive_backend::SyncEngine> sync_engine_;
126
127  scoped_refptr<base::SequencedWorkerPool> worker_pool_;
128  scoped_refptr<base::SequencedTaskRunner> worker_task_runner_;
129
130  DISALLOW_COPY_AND_ASSIGN(SyncEngineTest);
131};
132
133TEST_F(SyncEngineTest, OriginTest) {
134  GURL origin("chrome-extension://app_0");
135
136  SyncStatusCode sync_status;
137  std::string status;
138
139  sync_engine()->RegisterOrigin(
140      origin,
141      CreateResultReceiver(&sync_status));
142  WaitForWorkerTaskRunner();
143  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
144  ASSERT_TRUE(FindOriginStatus(origin, &status));
145  EXPECT_EQ("Registered", status);
146
147  sync_engine()->DisableOrigin(
148      origin,
149      CreateResultReceiver(&sync_status));
150  WaitForWorkerTaskRunner();
151  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
152  ASSERT_TRUE(FindOriginStatus(origin, &status));
153  EXPECT_EQ("Disabled", status);
154
155  sync_engine()->EnableOrigin(
156      origin,
157      CreateResultReceiver(&sync_status));
158  WaitForWorkerTaskRunner();
159  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
160  ASSERT_TRUE(FindOriginStatus(origin, &status));
161  EXPECT_EQ("Enabled", status);
162
163  sync_engine()->UninstallOrigin(
164      origin,
165      RemoteFileSyncService::UNINSTALL_AND_KEEP_REMOTE,
166      CreateResultReceiver(&sync_status));
167  WaitForWorkerTaskRunner();
168  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
169  EXPECT_FALSE(FindOriginStatus(origin, &status));
170  EXPECT_EQ("Uninstalled", status);
171}
172
173TEST_F(SyncEngineTest, GetOriginStatusMap) {
174  SyncStatusCode sync_status = SYNC_STATUS_UNKNOWN;
175
176  sync_engine()->RegisterOrigin(GURL("chrome-extension://app_0"),
177                                CreateResultReceiver(&sync_status));
178  WaitForWorkerTaskRunner();
179  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
180
181  sync_engine()->RegisterOrigin(GURL("chrome-extension://app_1"),
182                                CreateResultReceiver(&sync_status));
183  WaitForWorkerTaskRunner();
184  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
185
186  scoped_ptr<RemoteOriginStatusMap> status_map;
187  sync_engine()->GetOriginStatusMap(CreateResultReceiver(&status_map));
188  WaitForWorkerTaskRunner();
189  ASSERT_EQ(2u, status_map->size());
190  EXPECT_EQ("Registered", (*status_map)[GURL("chrome-extension://app_0")]);
191  EXPECT_EQ("Registered", (*status_map)[GURL("chrome-extension://app_1")]);
192
193  sync_engine()->DisableOrigin(GURL("chrome-extension://app_1"),
194                               CreateResultReceiver(&sync_status));
195  WaitForWorkerTaskRunner();
196  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
197
198  sync_engine()->GetOriginStatusMap(CreateResultReceiver(&status_map));
199  WaitForWorkerTaskRunner();
200  ASSERT_EQ(2u, status_map->size());
201  EXPECT_EQ("Registered", (*status_map)[GURL("chrome-extension://app_0")]);
202  EXPECT_EQ("Disabled", (*status_map)[GURL("chrome-extension://app_1")]);
203}
204
205TEST_F(SyncEngineTest, UpdateServiceState) {
206  struct {
207    RemoteServiceState state;
208    const char* description;
209  } test_data[] = {
210    {REMOTE_SERVICE_OK, "OK"},
211    {REMOTE_SERVICE_TEMPORARY_UNAVAILABLE, "TEMPORARY_UNAVAILABLE"},
212    {REMOTE_SERVICE_AUTHENTICATION_REQUIRED, "AUTHENTICATION_REQUIRED"},
213    {REMOTE_SERVICE_DISABLED, "DISABLED"},
214  };
215
216  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
217    PostUpdateServiceState(test_data[i].state, test_data[i].description);
218    EXPECT_EQ(test_data[i].state, sync_engine()->GetCurrentState())
219        << "Expected state: REMOTE_SERVICE_" << test_data[i].description;
220  }
221}
222
223TEST_F(SyncEngineTest, ProcessRemoteChange) {
224  SyncStatusCode sync_status;
225  fileapi::FileSystemURL url;
226  sync_engine()->ProcessRemoteChange(CreateResultReceiver(&sync_status, &url));
227  WaitForWorkerTaskRunner();
228  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
229}
230
231}  // namespace drive_backend
232}  // namespace sync_file_system
233