sync_engine_unittest.cc revision 03b57e008b61dfcb1fbad3aea950ae0e001748b0 
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 /* drive_task_runner */,
51        profile_dir_.path(),
52        NULL /* task_logger */,
53        NULL /* notification_manager */,
54        NULL /* extension_service */,
55        NULL /* signin_manager */,
56        NULL /* token_service */,
57        NULL /* request_context */,
58        scoped_ptr<SyncEngine::DriveServiceFactory>(),
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    sync_engine_->OnReadyToSendRequests();
67
68    WaitForWorkerTaskRunner();
69  }
70
71  virtual void TearDown() OVERRIDE {
72    sync_engine_.reset();
73    WaitForWorkerTaskRunner();
74    worker_pool_->Shutdown();
75    base::RunLoop().RunUntilIdle();
76  }
77
78  bool FindOriginStatus(const GURL& origin, std::string* status) {
79    scoped_ptr<RemoteOriginStatusMap> status_map;
80    sync_engine()->GetOriginStatusMap(CreateResultReceiver(&status_map));
81    WaitForWorkerTaskRunner();
82
83    RemoteOriginStatusMap::const_iterator itr = status_map->find(origin);
84    if (itr == status_map->end())
85      return false;
86
87    *status = itr->second;
88    // If an origin is uninstalled, it should not be found actually.
89    if (*status == "Uninstalled")
90      return false;
91    return true;
92  }
93
94  void PostUpdateServiceState(RemoteServiceState state,
95                              const std::string& description) {
96    worker_task_runner_->PostTask(
97        FROM_HERE,
98        base::Bind(&FakeSyncWorker::UpdateServiceState,
99                   base::Unretained(fake_sync_worker()),
100                   state,
101                   description));
102    WaitForWorkerTaskRunner();
103  }
104
105  void WaitForWorkerTaskRunner() {
106    DCHECK(worker_task_runner_);
107
108    base::RunLoop run_loop;
109    worker_task_runner_->PostTask(
110        FROM_HERE,
111        RelayCallbackToCurrentThread(
112            FROM_HERE, run_loop.QuitClosure()));
113    run_loop.Run();
114  }
115
116  // Accessors
117  SyncEngine* sync_engine() { return sync_engine_.get(); }
118
119  FakeSyncWorker* fake_sync_worker() {
120    return static_cast<FakeSyncWorker*>(sync_engine_->sync_worker_.get());
121  }
122
123 private:
124  content::TestBrowserThreadBundle browser_threads_;
125  base::ScopedTempDir profile_dir_;
126  scoped_ptr<drive_backend::SyncEngine> sync_engine_;
127
128  scoped_refptr<base::SequencedWorkerPool> worker_pool_;
129  scoped_refptr<base::SequencedTaskRunner> worker_task_runner_;
130
131  DISALLOW_COPY_AND_ASSIGN(SyncEngineTest);
132};
133
134TEST_F(SyncEngineTest, OriginTest) {
135  GURL origin("chrome-extension://app_0");
136
137  SyncStatusCode sync_status;
138  std::string status;
139
140  sync_engine()->RegisterOrigin(
141      origin,
142      CreateResultReceiver(&sync_status));
143  WaitForWorkerTaskRunner();
144  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
145  ASSERT_TRUE(FindOriginStatus(origin, &status));
146  EXPECT_EQ("Registered", status);
147
148  sync_engine()->DisableOrigin(
149      origin,
150      CreateResultReceiver(&sync_status));
151  WaitForWorkerTaskRunner();
152  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
153  ASSERT_TRUE(FindOriginStatus(origin, &status));
154  EXPECT_EQ("Disabled", status);
155
156  sync_engine()->EnableOrigin(
157      origin,
158      CreateResultReceiver(&sync_status));
159  WaitForWorkerTaskRunner();
160  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
161  ASSERT_TRUE(FindOriginStatus(origin, &status));
162  EXPECT_EQ("Enabled", status);
163
164  sync_engine()->UninstallOrigin(
165      origin,
166      RemoteFileSyncService::UNINSTALL_AND_KEEP_REMOTE,
167      CreateResultReceiver(&sync_status));
168  WaitForWorkerTaskRunner();
169  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
170  EXPECT_FALSE(FindOriginStatus(origin, &status));
171  EXPECT_EQ("Uninstalled", status);
172}
173
174TEST_F(SyncEngineTest, GetOriginStatusMap) {
175  SyncStatusCode sync_status = SYNC_STATUS_UNKNOWN;
176
177  sync_engine()->RegisterOrigin(GURL("chrome-extension://app_0"),
178                                CreateResultReceiver(&sync_status));
179  WaitForWorkerTaskRunner();
180  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
181
182  sync_engine()->RegisterOrigin(GURL("chrome-extension://app_1"),
183                                CreateResultReceiver(&sync_status));
184  WaitForWorkerTaskRunner();
185  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
186
187  scoped_ptr<RemoteOriginStatusMap> status_map;
188  sync_engine()->GetOriginStatusMap(CreateResultReceiver(&status_map));
189  WaitForWorkerTaskRunner();
190  ASSERT_EQ(2u, status_map->size());
191  EXPECT_EQ("Registered", (*status_map)[GURL("chrome-extension://app_0")]);
192  EXPECT_EQ("Registered", (*status_map)[GURL("chrome-extension://app_1")]);
193
194  sync_engine()->DisableOrigin(GURL("chrome-extension://app_1"),
195                               CreateResultReceiver(&sync_status));
196  WaitForWorkerTaskRunner();
197  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
198
199  sync_engine()->GetOriginStatusMap(CreateResultReceiver(&status_map));
200  WaitForWorkerTaskRunner();
201  ASSERT_EQ(2u, status_map->size());
202  EXPECT_EQ("Registered", (*status_map)[GURL("chrome-extension://app_0")]);
203  EXPECT_EQ("Disabled", (*status_map)[GURL("chrome-extension://app_1")]);
204}
205
206TEST_F(SyncEngineTest, UpdateServiceState) {
207  struct {
208    RemoteServiceState state;
209    const char* description;
210  } test_data[] = {
211    {REMOTE_SERVICE_OK, "OK"},
212    {REMOTE_SERVICE_TEMPORARY_UNAVAILABLE, "TEMPORARY_UNAVAILABLE"},
213    {REMOTE_SERVICE_AUTHENTICATION_REQUIRED, "AUTHENTICATION_REQUIRED"},
214    {REMOTE_SERVICE_DISABLED, "DISABLED"},
215  };
216
217  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
218    PostUpdateServiceState(test_data[i].state, test_data[i].description);
219    EXPECT_EQ(test_data[i].state, sync_engine()->GetCurrentState())
220        << "Expected state: REMOTE_SERVICE_" << test_data[i].description;
221  }
222}
223
224TEST_F(SyncEngineTest, ProcessRemoteChange) {
225  SyncStatusCode sync_status;
226  storage::FileSystemURL url;
227  sync_engine()->ProcessRemoteChange(CreateResultReceiver(&sync_status, &url));
228  WaitForWorkerTaskRunner();
229  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
230}
231
232}  // namespace drive_backend
233}  // namespace sync_file_system
234