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/drive_file_sync_service.h" 6 7 #include <algorithm> 8 9 #include "base/file_util.h" 10 #include "base/message_loop/message_loop.h" 11 #include "base/stl_util.h" 12 #include "base/strings/stringprintf.h" 13 #include "base/strings/utf_string_conversions.h" 14 #include "base/threading/sequenced_worker_pool.h" 15 #include "chrome/browser/drive/drive_uploader.h" 16 #include "chrome/browser/drive/fake_drive_service.h" 17 #include "chrome/browser/sync_file_system/drive_backend/api_util.h" 18 #include "chrome/browser/sync_file_system/drive_backend/drive_file_sync_util.h" 19 #include "chrome/browser/sync_file_system/drive_backend/drive_metadata_store.h" 20 #include "chrome/browser/sync_file_system/drive_backend/fake_drive_service_helper.h" 21 #include "chrome/browser/sync_file_system/fake_remote_change_processor.h" 22 #include "chrome/browser/sync_file_system/local/canned_syncable_file_system.h" 23 #include "chrome/browser/sync_file_system/local/local_file_sync_context.h" 24 #include "chrome/browser/sync_file_system/local/local_file_sync_service.h" 25 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.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/test/test_browser_thread.h" 29 #include "content/public/test/test_browser_thread_bundle.h" 30 #include "testing/gtest/include/gtest/gtest.h" 31 #include "webkit/browser/fileapi/file_system_context.h" 32 33 #define FPL(path) FILE_PATH_LITERAL(path) 34 35 using content::BrowserThread; 36 37 using google_apis::GDataErrorCode; 38 using google_apis::ResourceEntry; 39 40 namespace sync_file_system { 41 42 using drive_backend::APIUtil; 43 using drive_backend::APIUtilInterface; 44 using drive_backend::FakeDriveServiceHelper; 45 46 namespace { 47 48 void SyncResultCallback(bool* done, 49 SyncStatusCode* status_out, 50 fileapi::FileSystemURL* url_out, 51 SyncStatusCode status, 52 const fileapi::FileSystemURL& url) { 53 EXPECT_FALSE(*done); 54 *status_out = status; 55 *url_out = url; 56 *done = true; 57 } 58 59 void SyncStatusResultCallback(bool* done, 60 SyncStatusCode* status_out, 61 SyncStatusCode status) { 62 EXPECT_FALSE(*done); 63 *status_out = status; 64 *done = true; 65 } 66 67 void DatabaseInitResultCallback(bool* done, 68 SyncStatusCode* status_out, 69 bool* created_out, 70 SyncStatusCode status, 71 bool created) { 72 EXPECT_FALSE(*done); 73 *status_out = status; 74 *created_out = created; 75 *done = true; 76 } 77 78 } // namespace 79 80 class DriveFileSyncServiceSyncTest : public testing::Test { 81 public: 82 DriveFileSyncServiceSyncTest() 83 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {} 84 85 virtual ~DriveFileSyncServiceSyncTest() { 86 } 87 88 virtual void SetUp() OVERRIDE { 89 // TODO(tzik): Set up TestExtensionSystem to support simulated relaunch. 90 91 RegisterSyncableFileSystem(); 92 local_sync_service_.reset(new LocalFileSyncService(&profile_)); 93 94 fake_drive_service_ = new drive::FakeDriveService(); 95 fake_drive_service_->Initialize(); 96 ASSERT_TRUE(fake_drive_service_->LoadAccountMetadataForWapi( 97 "sync_file_system/account_metadata.json")); 98 ASSERT_TRUE(fake_drive_service_->LoadResourceListForWapi( 99 "gdata/root_feed.json")); 100 101 drive_uploader_ = new drive::DriveUploader( 102 fake_drive_service_, base::MessageLoopProxy::current().get()); 103 104 fake_drive_helper_.reset(new FakeDriveServiceHelper( 105 fake_drive_service_, drive_uploader_)); 106 107 bool done = false; 108 SyncStatusCode status = SYNC_STATUS_UNKNOWN; 109 bool created = false; 110 scoped_ptr<DriveMetadataStore> metadata_store( 111 new DriveMetadataStore(fake_drive_helper_->base_dir_path(), 112 base::MessageLoopProxy::current().get())); 113 metadata_store->Initialize( 114 base::Bind(&DatabaseInitResultCallback, &done, &status, &created)); 115 FlushMessageLoop(); 116 EXPECT_TRUE(done); 117 EXPECT_EQ(SYNC_STATUS_OK, status); 118 EXPECT_TRUE(created); 119 120 scoped_ptr<APIUtil> api_util(APIUtil::CreateForTesting( 121 fake_drive_helper_->base_dir_path().AppendASCII("tmp"), 122 scoped_ptr<drive::DriveServiceInterface>(fake_drive_service_), 123 scoped_ptr<drive::DriveUploaderInterface>(drive_uploader_))); 124 125 remote_sync_service_ = DriveFileSyncService::CreateForTesting( 126 &profile_, 127 fake_drive_helper_->base_dir_path(), 128 api_util.PassAs<APIUtilInterface>(), 129 metadata_store.Pass()); 130 131 local_sync_service_->SetLocalChangeProcessor(remote_sync_service_.get()); 132 remote_sync_service_->SetRemoteChangeProcessor(local_sync_service_.get()); 133 } 134 135 virtual void TearDown() OVERRIDE { 136 drive_uploader_ = NULL; 137 fake_drive_service_ = NULL; 138 remote_sync_service_.reset(); 139 local_sync_service_.reset(); 140 FlushMessageLoop(); 141 142 typedef std::map<GURL, CannedSyncableFileSystem*>::iterator iterator; 143 for (iterator itr = file_systems_.begin(); 144 itr != file_systems_.end(); ++itr) { 145 itr->second->TearDown(); 146 delete itr->second; 147 } 148 file_systems_.clear(); 149 150 FlushMessageLoop(); 151 RevokeSyncableFileSystem(); 152 } 153 154 protected: 155 void RegisterOrigin(const GURL& origin) { 156 if (!ContainsKey(file_systems_, origin)) { 157 CannedSyncableFileSystem* file_system = new CannedSyncableFileSystem( 158 origin, 159 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO).get(), 160 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE) 161 .get()); 162 163 bool done = false; 164 SyncStatusCode status = SYNC_STATUS_UNKNOWN; 165 file_system->SetUp(); 166 local_sync_service_->MaybeInitializeFileSystemContext( 167 origin, file_system->file_system_context(), 168 base::Bind(&SyncStatusResultCallback, &done, &status)); 169 FlushMessageLoop(); 170 EXPECT_TRUE(done); 171 EXPECT_EQ(SYNC_STATUS_OK, status); 172 173 file_system->backend()->sync_context()-> 174 set_mock_notify_changes_duration_in_sec(0); 175 176 EXPECT_EQ(base::PLATFORM_FILE_OK, file_system->OpenFileSystem()); 177 file_systems_[origin] = file_system; 178 } 179 180 bool done = false; 181 SyncStatusCode status = SYNC_STATUS_UNKNOWN; 182 remote_sync_service_->RegisterOriginForTrackingChanges( 183 origin, base::Bind(&SyncStatusResultCallback, &done, &status)); 184 FlushMessageLoop(); 185 EXPECT_TRUE(done); 186 EXPECT_EQ(SYNC_STATUS_OK, status); 187 } 188 189 void AddLocalFolder(const GURL& origin, 190 const base::FilePath& path) { 191 ASSERT_TRUE(ContainsKey(file_systems_, origin)); 192 EXPECT_EQ(base::PLATFORM_FILE_OK, 193 file_systems_[origin]->CreateDirectory( 194 CreateSyncableFileSystemURL(origin, path))); 195 } 196 197 void AddOrUpdateLocalFile(const GURL& origin, 198 const base::FilePath& path, 199 const std::string& content) { 200 fileapi::FileSystemURL url(CreateSyncableFileSystemURL(origin, path)); 201 ASSERT_TRUE(ContainsKey(file_systems_, origin)); 202 EXPECT_EQ(base::PLATFORM_FILE_OK, file_systems_[origin]->CreateFile(url)); 203 int64 bytes_written = file_systems_[origin]->WriteString(url, content); 204 EXPECT_EQ(static_cast<int64>(content.size()), bytes_written); 205 FlushMessageLoop(); 206 } 207 208 void UpdateLocalFile(const GURL& origin, 209 const base::FilePath& path, 210 const std::string& content) { 211 ASSERT_TRUE(ContainsKey(file_systems_, origin)); 212 int64 bytes_written = file_systems_[origin]->WriteString( 213 CreateSyncableFileSystemURL(origin, path), content); 214 EXPECT_EQ(static_cast<int64>(content.size()), bytes_written); 215 FlushMessageLoop(); 216 } 217 218 void RemoveLocal(const GURL& origin, const base::FilePath& path) { 219 ASSERT_TRUE(ContainsKey(file_systems_, origin)); 220 EXPECT_EQ(base::PLATFORM_FILE_OK, 221 file_systems_[origin]->Remove( 222 CreateSyncableFileSystemURL(origin, path), 223 true /* recursive */)); 224 FlushMessageLoop(); 225 } 226 227 SyncStatusCode ProcessLocalChange() { 228 bool done = false; 229 SyncStatusCode status = SYNC_STATUS_UNKNOWN; 230 fileapi::FileSystemURL url; 231 local_sync_service_->ProcessLocalChange( 232 base::Bind(&SyncResultCallback, &done, &status, &url)); 233 FlushMessageLoop(); 234 EXPECT_TRUE(done); 235 if (status != SYNC_STATUS_NO_CHANGE_TO_SYNC) 236 local_sync_service_->ClearSyncFlagForURL(url); 237 return status; 238 } 239 240 SyncStatusCode ProcessRemoteChange() { 241 bool done = false; 242 SyncStatusCode status = SYNC_STATUS_UNKNOWN; 243 fileapi::FileSystemURL url; 244 remote_sync_service_->ProcessRemoteChange( 245 base::Bind(&SyncResultCallback, &done, &status, &url)); 246 FlushMessageLoop(); 247 EXPECT_TRUE(done); 248 if (status != SYNC_STATUS_NO_CHANGE_TO_SYNC) 249 local_sync_service_->ClearSyncFlagForURL(url); 250 return status; 251 } 252 253 SyncStatusCode ProcessChangesUntilDone() { 254 remote_sync_service_->OnNotificationReceived(); 255 FlushMessageLoop(); 256 257 SyncStatusCode local_sync_status; 258 SyncStatusCode remote_sync_status; 259 do { 260 local_sync_status = ProcessLocalChange(); 261 if (local_sync_status != SYNC_STATUS_OK && 262 local_sync_status != SYNC_STATUS_NO_CHANGE_TO_SYNC) 263 return local_sync_status; 264 265 remote_sync_status = ProcessRemoteChange(); 266 if (remote_sync_status != SYNC_STATUS_OK && 267 remote_sync_status != SYNC_STATUS_NO_CHANGE_TO_SYNC) 268 return remote_sync_status; 269 } while (local_sync_status != SYNC_STATUS_NO_CHANGE_TO_SYNC && 270 remote_sync_status != SYNC_STATUS_NO_CHANGE_TO_SYNC); 271 return SYNC_STATUS_OK; 272 } 273 274 // Verifies local and remote files/folders are consistent. 275 // This function checks: 276 // - Each registered origin has corresponding remote folder. 277 // - Each local file/folder has corresponding remote one. 278 // - Each remote file/folder has corresponding local one. 279 // TODO(tzik): Handle conflict case. i.e. allow remote file has different 280 // file content if the corresponding local file conflicts to it. 281 void VerifyConsistency() { 282 std::string sync_root_folder_id; 283 GDataErrorCode error = 284 fake_drive_helper_->GetSyncRootFolderID(&sync_root_folder_id); 285 if (sync_root_folder_id.empty()) { 286 EXPECT_EQ(google_apis::HTTP_NOT_FOUND, error); 287 EXPECT_TRUE(file_systems_.empty()); 288 return; 289 } 290 EXPECT_EQ(google_apis::HTTP_SUCCESS, error); 291 292 ScopedVector<ResourceEntry> remote_entries; 293 EXPECT_EQ(google_apis::HTTP_SUCCESS, 294 fake_drive_helper_->ListFilesInFolder( 295 sync_root_folder_id, &remote_entries)); 296 std::map<std::string, const ResourceEntry*> origin_root_by_title; 297 for (ScopedVector<ResourceEntry>::iterator itr = remote_entries.begin(); 298 itr != remote_entries.end(); 299 ++itr) { 300 const ResourceEntry& remote_entry = **itr; 301 EXPECT_FALSE(ContainsKey(origin_root_by_title, remote_entry.title())); 302 origin_root_by_title[remote_entry.title()] = *itr; 303 } 304 305 for (std::map<GURL, CannedSyncableFileSystem*>::const_iterator itr = 306 file_systems_.begin(); 307 itr != file_systems_.end(); ++itr) { 308 const GURL& origin = itr->first; 309 SCOPED_TRACE(testing::Message() << "Verifying origin: " << origin); 310 CannedSyncableFileSystem* file_system = itr->second; 311 ASSERT_TRUE(ContainsKey(origin_root_by_title, origin.host())); 312 VerifyConsistencyForFolder( 313 origin, base::FilePath(), 314 origin_root_by_title[origin.host()]->resource_id(), 315 file_system); 316 } 317 } 318 319 void VerifyConsistencyForOrigin(const GURL& origin) { 320 std::string sync_root_folder_id; 321 ASSERT_EQ(google_apis::HTTP_SUCCESS, 322 fake_drive_helper_->GetSyncRootFolderID(&sync_root_folder_id)); 323 ASSERT_FALSE(sync_root_folder_id.empty()); 324 325 ScopedVector<ResourceEntry> origin_folder; 326 EXPECT_EQ(google_apis::HTTP_SUCCESS, 327 fake_drive_helper_->SearchByTitle( 328 sync_root_folder_id, origin.host(), &origin_folder)); 329 ASSERT_EQ(1u, origin_folder.size()); 330 331 ASSERT_TRUE(ContainsKey(file_systems_, origin)); 332 VerifyConsistencyForFolder( 333 origin, base::FilePath(), 334 origin_folder[0]->resource_id(), 335 file_systems_[origin]); 336 } 337 338 void VerifyConsistencyForFolder(const GURL& origin, 339 const base::FilePath& path, 340 const std::string& folder_id, 341 CannedSyncableFileSystem* file_system) { 342 SCOPED_TRACE(testing::Message() << "Verifying path: " << path.value()); 343 344 ScopedVector<ResourceEntry> remote_entries; 345 EXPECT_EQ(google_apis::HTTP_SUCCESS, 346 fake_drive_helper_->ListFilesInFolder( 347 folder_id, &remote_entries)); 348 std::map<std::string, const ResourceEntry*> remote_entry_by_title; 349 for (ScopedVector<ResourceEntry>::iterator itr = remote_entries.begin(); 350 itr != remote_entries.end(); 351 ++itr) { 352 const ResourceEntry& remote_entry = **itr; 353 EXPECT_FALSE(ContainsKey(remote_entry_by_title, remote_entry.title())); 354 remote_entry_by_title[remote_entry.title()] = *itr; 355 } 356 357 fileapi::FileSystemURL url(CreateSyncableFileSystemURL(origin, path)); 358 CannedSyncableFileSystem::FileEntryList local_entries; 359 EXPECT_EQ(base::PLATFORM_FILE_OK, 360 file_system->ReadDirectory(url, &local_entries)); 361 for (CannedSyncableFileSystem::FileEntryList::iterator itr = 362 local_entries.begin(); 363 itr != local_entries.end(); 364 ++itr) { 365 const fileapi::DirectoryEntry& local_entry = *itr; 366 fileapi::FileSystemURL entry_url( 367 CreateSyncableFileSystemURL(origin, path.Append(local_entry.name))); 368 std::string title = DriveFileSyncService::PathToTitle(entry_url.path()); 369 ASSERT_TRUE(ContainsKey(remote_entry_by_title, title)); 370 const ResourceEntry& remote_entry = *remote_entry_by_title[title]; 371 if (local_entry.is_directory) { 372 ASSERT_TRUE(remote_entry.is_folder()); 373 VerifyConsistencyForFolder(origin, entry_url.path(), 374 remote_entry.resource_id(), 375 file_system); 376 } else { 377 ASSERT_TRUE(remote_entry.is_file()); 378 VerifyConsistencyForFile(origin, entry_url.path(), 379 remote_entry.resource_id(), 380 file_system); 381 } 382 remote_entry_by_title.erase(title); 383 } 384 385 EXPECT_TRUE(remote_entry_by_title.empty()); 386 } 387 388 void VerifyConsistencyForFile(const GURL& origin, 389 const base::FilePath& path, 390 const std::string& file_id, 391 CannedSyncableFileSystem* file_system) { 392 fileapi::FileSystemURL url(CreateSyncableFileSystemURL(origin, path)); 393 std::string file_content; 394 EXPECT_EQ(google_apis::HTTP_SUCCESS, 395 fake_drive_helper_->ReadFile(file_id, &file_content)); 396 EXPECT_EQ(base::PLATFORM_FILE_OK, 397 file_system->VerifyFile(url, file_content)); 398 } 399 400 void FlushMessageLoop() { 401 base::MessageLoop::current()->RunUntilIdle(); 402 BrowserThread::GetBlockingPool()->FlushForTesting(); 403 base::MessageLoop::current()->RunUntilIdle(); 404 } 405 406 void TestInitialization(); 407 void TestLocalToRemoteBasic(); 408 void TestRemoteToLocalBasic(); 409 void TestLocalFileUpdate(); 410 void TestRemoteFileUpdate(); 411 void TestLocalFileDeletion(); 412 void TestRemoteFileDeletion(); 413 414 content::TestBrowserThreadBundle thread_bundle_; 415 416 TestingProfile profile_; 417 418 drive::FakeDriveService* fake_drive_service_; 419 drive::DriveUploader* drive_uploader_; 420 scoped_ptr<FakeDriveServiceHelper> fake_drive_helper_; 421 std::map<GURL, CannedSyncableFileSystem*> file_systems_; 422 423 scoped_ptr<DriveFileSyncService> remote_sync_service_; 424 scoped_ptr<LocalFileSyncService> local_sync_service_; 425 426 private: 427 DISALLOW_COPY_AND_ASSIGN(DriveFileSyncServiceSyncTest); 428 }; 429 430 void DriveFileSyncServiceSyncTest::TestInitialization() { 431 EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone()); 432 VerifyConsistency(); 433 } 434 435 void DriveFileSyncServiceSyncTest::TestLocalToRemoteBasic() { 436 const GURL kOrigin("chrome-extension://example"); 437 438 RegisterOrigin(kOrigin); 439 AddOrUpdateLocalFile(kOrigin, base::FilePath(FPL("file")), "abcde"); 440 441 EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone()); 442 VerifyConsistency(); 443 } 444 445 void DriveFileSyncServiceSyncTest::TestRemoteToLocalBasic() { 446 const GURL kOrigin("chrome-extension://example"); 447 448 std::string sync_root_folder_id; 449 EXPECT_EQ(google_apis::HTTP_CREATED, 450 fake_drive_helper_->AddOrphanedFolder( 451 APIUtil::GetSyncRootDirectoryName(), 452 &sync_root_folder_id)); 453 454 std::string origin_root_folder_id; 455 EXPECT_EQ(google_apis::HTTP_CREATED, 456 fake_drive_helper_->AddFolder( 457 sync_root_folder_id, kOrigin.host(), &origin_root_folder_id)); 458 459 RegisterOrigin(kOrigin); 460 461 std::string file_id; 462 EXPECT_EQ(google_apis::HTTP_SUCCESS, 463 fake_drive_helper_->AddFile( 464 origin_root_folder_id, "file", "abcde", &file_id)); 465 466 EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone()); 467 VerifyConsistency(); 468 } 469 470 void DriveFileSyncServiceSyncTest::TestLocalFileUpdate() { 471 const GURL kOrigin("chrome-extension://example"); 472 const base::FilePath kPath(FPL("file")); 473 474 RegisterOrigin(kOrigin); 475 AddOrUpdateLocalFile(kOrigin, kPath, "abcde"); 476 477 EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone()); 478 VerifyConsistencyForOrigin(kOrigin); 479 480 UpdateLocalFile(kOrigin, kPath, "1234567890"); 481 482 EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone()); 483 VerifyConsistency(); 484 } 485 486 void DriveFileSyncServiceSyncTest::TestRemoteFileUpdate() { 487 const GURL kOrigin("chrome-extension://example"); 488 const base::FilePath kPath(FPL("file")); 489 const std::string kTitle(DriveFileSyncService::PathToTitle(kPath)); 490 491 std::string sync_root_folder_id; 492 EXPECT_EQ(google_apis::HTTP_CREATED, 493 fake_drive_helper_->AddOrphanedFolder( 494 APIUtil::GetSyncRootDirectoryName(), 495 &sync_root_folder_id)); 496 497 std::string origin_root_folder_id; 498 EXPECT_EQ(google_apis::HTTP_CREATED, 499 fake_drive_helper_->AddFolder( 500 sync_root_folder_id, kOrigin.host(), &origin_root_folder_id)); 501 502 std::string remote_file_id; 503 EXPECT_EQ(google_apis::HTTP_SUCCESS, 504 fake_drive_helper_->AddFile( 505 origin_root_folder_id, kTitle, "abcde", &remote_file_id)); 506 507 RegisterOrigin(kOrigin); 508 EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone()); 509 VerifyConsistencyForOrigin(kOrigin); 510 511 EXPECT_EQ(google_apis::HTTP_SUCCESS, 512 fake_drive_helper_->UpdateFile(remote_file_id, "1234567890")); 513 514 EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone()); 515 VerifyConsistency(); 516 } 517 518 void DriveFileSyncServiceSyncTest::TestLocalFileDeletion() { 519 const GURL kOrigin("chrome-extension://example"); 520 const base::FilePath kPath(FPL("file")); 521 522 RegisterOrigin(kOrigin); 523 AddOrUpdateLocalFile(kOrigin, kPath, "abcde"); 524 525 EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone()); 526 VerifyConsistencyForOrigin(kOrigin); 527 528 RemoveLocal(kOrigin, kPath); 529 530 EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone()); 531 VerifyConsistency(); 532 } 533 534 void DriveFileSyncServiceSyncTest::TestRemoteFileDeletion() { 535 const GURL kOrigin("chrome-extension://example"); 536 const base::FilePath kPath(FPL("file")); 537 const std::string kTitle(DriveFileSyncService::PathToTitle(kPath)); 538 539 std::string sync_root_folder_id; 540 EXPECT_EQ(google_apis::HTTP_CREATED, 541 fake_drive_helper_->AddOrphanedFolder( 542 APIUtil::GetSyncRootDirectoryName(), 543 &sync_root_folder_id)); 544 545 std::string origin_root_folder_id; 546 EXPECT_EQ(google_apis::HTTP_CREATED, 547 fake_drive_helper_->AddFolder( 548 sync_root_folder_id, kOrigin.host(), &origin_root_folder_id)); 549 550 std::string remote_file_id; 551 EXPECT_EQ(google_apis::HTTP_SUCCESS, 552 fake_drive_helper_->AddFile( 553 origin_root_folder_id, kTitle, "abcde", &remote_file_id)); 554 555 RegisterOrigin(kOrigin); 556 EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone()); 557 VerifyConsistencyForOrigin(kOrigin); 558 559 EXPECT_EQ(google_apis::HTTP_SUCCESS, 560 fake_drive_helper_->RemoveResource(remote_file_id)); 561 562 EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone()); 563 VerifyConsistency(); 564 } 565 566 TEST_F(DriveFileSyncServiceSyncTest, InitializationTest) { 567 ASSERT_FALSE(IsDriveAPIDisabled()); 568 TestInitialization(); 569 } 570 571 TEST_F(DriveFileSyncServiceSyncTest, InitializationTest_WAPI) { 572 ScopedDisableDriveAPI disable_drive_api; 573 TestInitialization(); 574 } 575 576 TEST_F(DriveFileSyncServiceSyncTest, LocalToRemoteBasicTest) { 577 ASSERT_FALSE(IsDriveAPIDisabled()); 578 TestLocalToRemoteBasic(); 579 } 580 581 TEST_F(DriveFileSyncServiceSyncTest, LocalToRemoteBasicTest_WAPI) { 582 ScopedDisableDriveAPI disable_drive_api; 583 TestLocalToRemoteBasic(); 584 } 585 586 TEST_F(DriveFileSyncServiceSyncTest, RemoteToLocalBasicTest) { 587 ASSERT_FALSE(IsDriveAPIDisabled()); 588 TestRemoteToLocalBasic(); 589 } 590 591 TEST_F(DriveFileSyncServiceSyncTest, RemoteToLocalBasicTest_WAPI) { 592 ScopedDisableDriveAPI disable_drive_api; 593 TestRemoteToLocalBasic(); 594 } 595 596 TEST_F(DriveFileSyncServiceSyncTest, LocalFileUpdateTest) { 597 ASSERT_FALSE(IsDriveAPIDisabled()); 598 TestLocalFileUpdate(); 599 } 600 601 TEST_F(DriveFileSyncServiceSyncTest, LocalFileUpdateTest_WAPI) { 602 ScopedDisableDriveAPI disable_drive_api; 603 TestLocalFileUpdate(); 604 } 605 606 TEST_F(DriveFileSyncServiceSyncTest, RemoteFileUpdateTest) { 607 ASSERT_FALSE(IsDriveAPIDisabled()); 608 TestRemoteFileUpdate(); 609 } 610 611 TEST_F(DriveFileSyncServiceSyncTest, RemoteFileUpdateTest_WAPI) { 612 ScopedDisableDriveAPI disable_drive_api; 613 TestRemoteFileUpdate(); 614 } 615 616 TEST_F(DriveFileSyncServiceSyncTest, LocalFileDeletionTest) { 617 ASSERT_FALSE(IsDriveAPIDisabled()); 618 TestLocalFileDeletion(); 619 } 620 621 TEST_F(DriveFileSyncServiceSyncTest, LocalFileDeletionTest_WAPI) { 622 ScopedDisableDriveAPI disable_drive_api; 623 TestLocalFileDeletion(); 624 } 625 626 TEST_F(DriveFileSyncServiceSyncTest, RemoteFileDeletionTest) { 627 ASSERT_FALSE(IsDriveAPIDisabled()); 628 TestRemoteFileDeletion(); 629 } 630 631 TEST_F(DriveFileSyncServiceSyncTest, RemoteFileDeletionTest_WAPI) { 632 ScopedDisableDriveAPI disable_drive_api; 633 TestRemoteFileDeletion(); 634 } 635 636 } // namespace sync_file_system 637