sync_engine_unittest.cc revision 5f1c94371a64b3196d4be9466099bb892df9b88e
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 NULL /* in_memory_env */)); 59 60 sync_engine_->InitializeForTesting( 61 fake_drive_service.Pass(), 62 scoped_ptr<drive::DriveUploaderInterface>(), 63 scoped_ptr<SyncWorkerInterface>(new FakeSyncWorker)); 64 sync_engine_->SetSyncEnabled(true); 65 sync_engine_->OnReadyToSendRequests(); 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