1 // Copyright (c) 2012 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 <vector> 6 7 #include "base/basictypes.h" 8 #include "base/bind.h" 9 #include "base/run_loop.h" 10 #include "base/single_thread_task_runner.h" 11 #include "base/stl_util.h" 12 #include "base/synchronization/waitable_event.h" 13 #include "base/thread_task_runner_handle.h" 14 #include "chrome/browser/sync_file_system/local/canned_syncable_file_system.h" 15 #include "chrome/browser/sync_file_system/local/local_file_sync_context.h" 16 #include "chrome/browser/sync_file_system/local/local_file_sync_service.h" 17 #include "chrome/browser/sync_file_system/local/mock_sync_status_observer.h" 18 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h" 19 #include "chrome/browser/sync_file_system/mock_remote_file_sync_service.h" 20 #include "chrome/browser/sync_file_system/sync_callbacks.h" 21 #include "chrome/browser/sync_file_system/sync_event_observer.h" 22 #include "chrome/browser/sync_file_system/sync_file_metadata.h" 23 #include "chrome/browser/sync_file_system/sync_file_system_service.h" 24 #include "chrome/browser/sync_file_system/sync_file_system_test_util.h" 25 #include "chrome/browser/sync_file_system/sync_status_code.h" 26 #include "chrome/browser/sync_file_system/syncable_file_system_util.h" 27 #include "chrome/test/base/testing_profile.h" 28 #include "content/public/browser/browser_thread.h" 29 #include "content/public/test/test_browser_thread_bundle.h" 30 #include "content/public/test/test_utils.h" 31 #include "storage/browser/fileapi/file_system_context.h" 32 #include "testing/gtest/include/gtest/gtest.h" 33 #include "third_party/leveldatabase/src/helpers/memenv/memenv.h" 34 #include "third_party/leveldatabase/src/include/leveldb/env.h" 35 36 using content::BrowserThread; 37 using storage::FileSystemURL; 38 using storage::FileSystemURLSet; 39 using ::testing::AnyNumber; 40 using ::testing::AtLeast; 41 using ::testing::InSequence; 42 using ::testing::InvokeWithoutArgs; 43 using ::testing::Return; 44 using ::testing::StrictMock; 45 using ::testing::_; 46 47 namespace sync_file_system { 48 49 namespace { 50 51 const char kOrigin[] = "http://example.com"; 52 53 template <typename R> struct AssignTrait { 54 typedef const R& ArgumentType; 55 }; 56 57 template <> struct AssignTrait<SyncFileStatus> { 58 typedef SyncFileStatus ArgumentType; 59 }; 60 61 template <typename R> 62 void AssignValueAndQuit(base::RunLoop* run_loop, 63 SyncStatusCode* status_out, R* value_out, 64 SyncStatusCode status, 65 typename AssignTrait<R>::ArgumentType value) { 66 DCHECK(status_out); 67 DCHECK(value_out); 68 DCHECK(run_loop); 69 *status_out = status; 70 *value_out = value; 71 run_loop->Quit(); 72 } 73 74 // This is called on IO thread. 75 void VerifyFileError(base::RunLoop* run_loop, 76 base::File::Error error) { 77 DCHECK(run_loop); 78 EXPECT_EQ(base::File::FILE_OK, error); 79 run_loop->Quit(); 80 } 81 82 } // namespace 83 84 class MockSyncEventObserver : public SyncEventObserver { 85 public: 86 MockSyncEventObserver() {} 87 virtual ~MockSyncEventObserver() {} 88 89 MOCK_METHOD3(OnSyncStateUpdated, 90 void(const GURL& app_origin, 91 SyncServiceState state, 92 const std::string& description)); 93 MOCK_METHOD4(OnFileSynced, 94 void(const storage::FileSystemURL& url, 95 SyncFileStatus status, 96 SyncAction action, 97 SyncDirection direction)); 98 }; 99 100 ACTION_P3(NotifyStateAndCallback, 101 mock_remote_service, service_state, operation_status) { 102 mock_remote_service->NotifyRemoteServiceStateUpdated( 103 service_state, "Test event."); 104 base::ThreadTaskRunnerHandle::Get()->PostTask( 105 FROM_HERE, base::Bind(arg1, operation_status)); 106 } 107 108 ACTION_P(RecordState, states) { 109 states->push_back(arg1); 110 } 111 112 ACTION_P(MockStatusCallback, status) { 113 base::ThreadTaskRunnerHandle::Get()->PostTask( 114 FROM_HERE, base::Bind(arg4, status)); 115 } 116 117 ACTION_P2(MockSyncFileCallback, status, url) { 118 base::ThreadTaskRunnerHandle::Get()->PostTask( 119 FROM_HERE, base::Bind(arg0, status, url)); 120 } 121 122 ACTION(InvokeCompletionClosure) { 123 base::ThreadTaskRunnerHandle::Get()->PostTask( 124 FROM_HERE, base::Bind(arg0)); 125 } 126 127 class SyncFileSystemServiceTest : public testing::Test { 128 protected: 129 SyncFileSystemServiceTest() 130 : thread_bundle_(content::TestBrowserThreadBundle::REAL_FILE_THREAD | 131 content::TestBrowserThreadBundle::REAL_IO_THREAD) {} 132 133 virtual void SetUp() OVERRIDE { 134 in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default())); 135 file_system_.reset(new CannedSyncableFileSystem( 136 GURL(kOrigin), 137 in_memory_env_.get(), 138 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO), 139 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE))); 140 141 scoped_ptr<LocalFileSyncService> local_service = 142 LocalFileSyncService::CreateForTesting(&profile_, in_memory_env_.get()); 143 remote_service_ = new StrictMock<MockRemoteFileSyncService>; 144 sync_service_.reset(new SyncFileSystemService(&profile_)); 145 146 EXPECT_CALL(*mock_remote_service(), 147 AddServiceObserver(_)).Times(1); 148 EXPECT_CALL(*mock_remote_service(), 149 AddFileStatusObserver(sync_service_.get())).Times(1); 150 EXPECT_CALL(*mock_remote_service(), 151 GetLocalChangeProcessor()) 152 .WillRepeatedly(Return(&local_change_processor_)); 153 EXPECT_CALL(*mock_remote_service(), 154 SetRemoteChangeProcessor(local_service.get())).Times(1); 155 156 sync_service_->Initialize( 157 local_service.Pass(), 158 scoped_ptr<RemoteFileSyncService>(remote_service_)); 159 160 // Disable auto sync by default. 161 EXPECT_CALL(*mock_remote_service(), SetSyncEnabled(false)).Times(1); 162 sync_service_->SetSyncEnabledForTesting(false); 163 164 file_system_->SetUp(CannedSyncableFileSystem::QUOTA_ENABLED); 165 } 166 167 virtual void TearDown() OVERRIDE { 168 sync_service_->Shutdown(); 169 file_system_->TearDown(); 170 RevokeSyncableFileSystem(); 171 content::RunAllPendingInMessageLoop(BrowserThread::FILE); 172 } 173 174 void InitializeApp() { 175 base::RunLoop run_loop; 176 SyncStatusCode status = SYNC_STATUS_UNKNOWN; 177 178 EXPECT_CALL(*mock_remote_service(), 179 RegisterOrigin(GURL(kOrigin), _)).Times(1); 180 181 // GetCurrentState may be called when a remote or local sync is scheduled 182 // by change notifications or by a timer. 183 EXPECT_CALL(*mock_remote_service(), GetCurrentState()) 184 .Times(AnyNumber()) 185 .WillRepeatedly(Return(REMOTE_SERVICE_OK)); 186 187 sync_service_->InitializeForApp( 188 file_system_->file_system_context(), 189 GURL(kOrigin), 190 AssignAndQuitCallback(&run_loop, &status)); 191 run_loop.Run(); 192 193 EXPECT_EQ(SYNC_STATUS_OK, status); 194 EXPECT_EQ(base::File::FILE_OK, file_system_->OpenFileSystem()); 195 } 196 197 // Calls InitializeForApp after setting up the mock remote service to 198 // perform following when RegisterOrigin is called: 199 // 1. Notify RemoteFileSyncService's observers of |state_to_notify| 200 // 2. Run the given callback with |status_to_return|. 201 // 202 // ..and verifies if following conditions are met: 203 // 1. The SyncEventObserver of the service is called with 204 // |expected_states| service state values. 205 // 2. InitializeForApp's callback is called with |expected_status| 206 void InitializeAppForObserverTest( 207 RemoteServiceState state_to_notify, 208 SyncStatusCode status_to_return, 209 const std::vector<SyncServiceState>& expected_states, 210 SyncStatusCode expected_status) { 211 StrictMock<MockSyncEventObserver> event_observer; 212 sync_service_->AddSyncEventObserver(&event_observer); 213 214 EnableSync(); 215 216 EXPECT_CALL(*mock_remote_service(), GetCurrentState()) 217 .Times(AnyNumber()) 218 .WillRepeatedly(Return(state_to_notify)); 219 220 EXPECT_CALL(*mock_remote_service(), 221 RegisterOrigin(GURL(kOrigin), _)) 222 .WillOnce(NotifyStateAndCallback(mock_remote_service(), 223 state_to_notify, 224 status_to_return)); 225 226 std::vector<SyncServiceState> actual_states; 227 EXPECT_CALL(event_observer, OnSyncStateUpdated(GURL(), _, _)) 228 .WillRepeatedly(RecordState(&actual_states)); 229 230 SyncStatusCode actual_status = SYNC_STATUS_UNKNOWN; 231 base::RunLoop run_loop; 232 sync_service_->InitializeForApp( 233 file_system_->file_system_context(), 234 GURL(kOrigin), 235 AssignAndQuitCallback(&run_loop, &actual_status)); 236 run_loop.Run(); 237 238 EXPECT_EQ(expected_status, actual_status); 239 ASSERT_EQ(expected_states.size(), actual_states.size()); 240 for (size_t i = 0; i < actual_states.size(); ++i) 241 EXPECT_EQ(expected_states[i], actual_states[i]); 242 243 sync_service_->RemoveSyncEventObserver(&event_observer); 244 } 245 246 FileSystemURL URL(const std::string& path) const { 247 return file_system_->URL(path); 248 } 249 250 StrictMock<MockRemoteFileSyncService>* mock_remote_service() { 251 return remote_service_; 252 } 253 254 StrictMock<MockLocalChangeProcessor>* mock_local_change_processor() { 255 return &local_change_processor_; 256 } 257 258 void EnableSync() { 259 EXPECT_CALL(*mock_remote_service(), SetSyncEnabled(true)).Times(1); 260 sync_service_->SetSyncEnabledForTesting(true); 261 } 262 263 content::TestBrowserThreadBundle thread_bundle_; 264 scoped_ptr<leveldb::Env> in_memory_env_; 265 TestingProfile profile_; 266 scoped_ptr<CannedSyncableFileSystem> file_system_; 267 268 // Their ownerships are transferred to SyncFileSystemService. 269 StrictMock<MockRemoteFileSyncService>* remote_service_; 270 StrictMock<MockLocalChangeProcessor> local_change_processor_; 271 272 scoped_ptr<SyncFileSystemService> sync_service_; 273 }; 274 275 TEST_F(SyncFileSystemServiceTest, InitializeForApp) { 276 InitializeApp(); 277 } 278 279 TEST_F(SyncFileSystemServiceTest, InitializeForAppSuccess) { 280 std::vector<SyncServiceState> expected_states; 281 expected_states.push_back(SYNC_SERVICE_RUNNING); 282 283 InitializeAppForObserverTest( 284 REMOTE_SERVICE_OK, 285 SYNC_STATUS_OK, 286 expected_states, 287 SYNC_STATUS_OK); 288 } 289 290 TEST_F(SyncFileSystemServiceTest, InitializeForAppWithNetworkFailure) { 291 std::vector<SyncServiceState> expected_states; 292 expected_states.push_back(SYNC_SERVICE_TEMPORARY_UNAVAILABLE); 293 294 // Notify REMOTE_SERVICE_TEMPORARY_UNAVAILABLE and callback with 295 // SYNC_STATUS_NETWORK_ERROR. This should let the 296 // InitializeApp fail. 297 InitializeAppForObserverTest( 298 REMOTE_SERVICE_TEMPORARY_UNAVAILABLE, 299 SYNC_STATUS_NETWORK_ERROR, 300 expected_states, 301 SYNC_STATUS_NETWORK_ERROR); 302 } 303 304 TEST_F(SyncFileSystemServiceTest, InitializeForAppWithError) { 305 std::vector<SyncServiceState> expected_states; 306 expected_states.push_back(SYNC_SERVICE_DISABLED); 307 308 // Notify REMOTE_SERVICE_DISABLED and callback with 309 // SYNC_STATUS_FAILED. This should let the InitializeApp fail. 310 InitializeAppForObserverTest( 311 REMOTE_SERVICE_DISABLED, 312 SYNC_STATUS_FAILED, 313 expected_states, 314 SYNC_STATUS_FAILED); 315 } 316 317 TEST_F(SyncFileSystemServiceTest, SimpleLocalSyncFlow) { 318 InitializeApp(); 319 320 StrictMock<MockSyncStatusObserver> status_observer; 321 322 EnableSync(); 323 file_system_->backend()->sync_context()-> 324 set_mock_notify_changes_duration_in_sec(0); 325 file_system_->AddSyncStatusObserver(&status_observer); 326 327 // We'll test one local sync for this file. 328 const FileSystemURL kFile(file_system_->URL("foo")); 329 330 base::RunLoop run_loop; 331 332 // We should get called OnSyncEnabled and OnWriteEnabled on kFile as in: 333 // 1. OnWriteEnabled when PrepareForSync(SYNC_SHARED) is finished and 334 // the target file is unlocked for writing 335 // 2. OnSyncEnabled x 3 times; 1) when CreateFile is finished, 2) when 336 // file is unlocked after PrepareForSync, and 3) when the sync is 337 // finished. 338 EXPECT_CALL(status_observer, OnWriteEnabled(kFile)) 339 .Times(AtLeast(1)); 340 341 { 342 ::testing::InSequence sequence; 343 EXPECT_CALL(status_observer, OnSyncEnabled(kFile)) 344 .Times(AtLeast(2)); 345 EXPECT_CALL(status_observer, OnSyncEnabled(kFile)) 346 .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit)); 347 } 348 349 // The local_change_processor's ApplyLocalChange should be called once 350 // with ADD_OR_UPDATE change for TYPE_FILE. 351 const FileChange change(FileChange::FILE_CHANGE_ADD_OR_UPDATE, 352 SYNC_FILE_TYPE_FILE); 353 EXPECT_CALL(*mock_local_change_processor(), 354 ApplyLocalChange(change, _, _, kFile, _)) 355 .WillOnce(MockStatusCallback(SYNC_STATUS_OK)); 356 EXPECT_CALL(*mock_remote_service(), ProcessRemoteChange(_)) 357 .WillRepeatedly(MockSyncFileCallback(SYNC_STATUS_NO_CHANGE_TO_SYNC, 358 FileSystemURL())); 359 360 EXPECT_CALL(*mock_remote_service(), PromoteDemotedChanges(_)) 361 .WillRepeatedly(InvokeCompletionClosure()); 362 363 EXPECT_EQ(base::File::FILE_OK, file_system_->CreateFile(kFile)); 364 365 run_loop.Run(); 366 367 file_system_->RemoveSyncStatusObserver(&status_observer); 368 } 369 370 TEST_F(SyncFileSystemServiceTest, SimpleRemoteSyncFlow) { 371 InitializeApp(); 372 373 EnableSync(); 374 375 base::RunLoop run_loop; 376 377 // We expect a set of method calls for starting a remote sync. 378 EXPECT_CALL(*mock_remote_service(), ProcessRemoteChange(_)) 379 .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit)); 380 381 // This should trigger a remote sync. 382 mock_remote_service()->NotifyRemoteChangeQueueUpdated(1); 383 384 run_loop.Run(); 385 } 386 387 TEST_F(SyncFileSystemServiceTest, SimpleSyncFlowWithFileBusy) { 388 InitializeApp(); 389 390 EnableSync(); 391 file_system_->backend()->sync_context()-> 392 set_mock_notify_changes_duration_in_sec(0); 393 394 const FileSystemURL kFile(file_system_->URL("foo")); 395 396 base::RunLoop run_loop; 397 398 { 399 InSequence sequence; 400 401 // Return with SYNC_STATUS_FILE_BUSY once. 402 EXPECT_CALL(*mock_remote_service(), ProcessRemoteChange(_)) 403 .WillOnce(MockSyncFileCallback(SYNC_STATUS_FILE_BUSY, 404 kFile)); 405 406 // ProcessRemoteChange should be called again when the becomes 407 // not busy. 408 EXPECT_CALL(*mock_remote_service(), ProcessRemoteChange(_)) 409 .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit)); 410 } 411 412 EXPECT_CALL(*mock_remote_service(), PromoteDemotedChanges(_)) 413 .WillRepeatedly(InvokeCompletionClosure()); 414 415 // We might also see an activity for local sync as we're going to make 416 // a local write operation on kFile. 417 EXPECT_CALL(*mock_local_change_processor(), 418 ApplyLocalChange(_, _, _, kFile, _)) 419 .Times(AnyNumber()); 420 421 // This should trigger a remote sync. 422 mock_remote_service()->NotifyRemoteChangeQueueUpdated(1); 423 424 // Start a local operation on the same file (to make it BUSY). 425 base::RunLoop verify_file_error_run_loop; 426 BrowserThread::PostTask( 427 BrowserThread::IO, 428 FROM_HERE, 429 base::Bind(&CannedSyncableFileSystem::DoCreateFile, 430 base::Unretained(file_system_.get()), 431 kFile, base::Bind(&VerifyFileError, 432 &verify_file_error_run_loop))); 433 434 run_loop.Run(); 435 436 mock_remote_service()->NotifyRemoteChangeQueueUpdated(0); 437 438 verify_file_error_run_loop.Run(); 439 } 440 441 #if defined(THREAD_SANITIZER) 442 // SyncFileSystemServiceTest.GetFileSyncStatus fails under ThreadSanitizer, 443 // see http://crbug.com/294904. 444 #define MAYBE_GetFileSyncStatus DISABLED_GetFileSyncStatus 445 #else 446 #define MAYBE_GetFileSyncStatus GetFileSyncStatus 447 #endif 448 TEST_F(SyncFileSystemServiceTest, MAYBE_GetFileSyncStatus) { 449 InitializeApp(); 450 451 const FileSystemURL kFile(file_system_->URL("foo")); 452 453 SyncStatusCode status; 454 SyncFileStatus sync_file_status; 455 456 // 1. The file is synced state. 457 { 458 base::RunLoop run_loop; 459 status = SYNC_STATUS_UNKNOWN; 460 sync_file_status = SYNC_FILE_STATUS_UNKNOWN; 461 sync_service_->GetFileSyncStatus( 462 kFile, 463 base::Bind(&AssignValueAndQuit<SyncFileStatus>, 464 &run_loop, &status, &sync_file_status)); 465 run_loop.Run(); 466 467 EXPECT_EQ(SYNC_STATUS_OK, status); 468 EXPECT_EQ(SYNC_FILE_STATUS_SYNCED, sync_file_status); 469 } 470 471 // 2. The file has pending local changes. 472 { 473 base::RunLoop run_loop; 474 EXPECT_EQ(base::File::FILE_OK, file_system_->CreateFile(kFile)); 475 476 status = SYNC_STATUS_UNKNOWN; 477 sync_file_status = SYNC_FILE_STATUS_UNKNOWN; 478 sync_service_->GetFileSyncStatus( 479 kFile, 480 base::Bind(&AssignValueAndQuit<SyncFileStatus>, 481 &run_loop, &status, &sync_file_status)); 482 run_loop.Run(); 483 484 EXPECT_EQ(SYNC_STATUS_OK, status); 485 EXPECT_EQ(SYNC_FILE_STATUS_HAS_PENDING_CHANGES, sync_file_status); 486 } 487 } 488 489 } // namespace sync_file_system 490