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_metadata_store.h" 6 7 #include <utility> 8 9 #include "base/files/file_path.h" 10 #include "base/files/scoped_temp_dir.h" 11 #include "base/message_loop/message_loop.h" 12 #include "base/single_thread_task_runner.h" 13 #include "base/stl_util.h" 14 #include "base/strings/string_number_conversions.h" 15 #include "base/strings/string_util.h" 16 #include "base/threading/thread.h" 17 #include "base/values.h" 18 #include "chrome/browser/sync_file_system/drive_backend/drive_file_sync_service.h" 19 #include "chrome/browser/sync_file_system/drive_backend/drive_file_sync_util.h" 20 #include "chrome/browser/sync_file_system/drive_backend/metadata_db_migration_util.h" 21 #include "chrome/browser/sync_file_system/sync_file_system.pb.h" 22 #include "chrome/browser/sync_file_system/syncable_file_system_util.h" 23 #include "content/public/browser/browser_thread.h" 24 #include "testing/gtest/include/gtest/gtest.h" 25 #include "third_party/leveldatabase/src/include/leveldb/db.h" 26 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h" 27 #include "webkit/browser/fileapi/isolated_context.h" 28 29 #define FPL FILE_PATH_LITERAL 30 31 using content::BrowserThread; 32 33 namespace sync_file_system { 34 35 namespace { 36 37 const char kOrigin[] = "chrome-extension://example"; 38 39 typedef DriveMetadataStore::ResourceIdByOrigin ResourceIdByOrigin; 40 typedef DriveMetadataStore::OriginByResourceId OriginByResourceId; 41 42 fileapi::FileSystemURL URL(const base::FilePath& path) { 43 return CreateSyncableFileSystemURL(GURL(kOrigin), path); 44 } 45 46 std::string GetResourceID(const ResourceIdByOrigin& sync_origins, 47 const GURL& origin) { 48 ResourceIdByOrigin::const_iterator itr = sync_origins.find(origin); 49 if (itr == sync_origins.end()) 50 return std::string(); 51 return itr->second; 52 } 53 54 std::string CreateResourceId(const std::string& resource_id) { 55 return IsDriveAPIDisabled() ? resource_id 56 : drive_backend::RemoveWapiIdPrefix(resource_id); 57 } 58 59 DriveMetadata CreateMetadata(const std::string& resource_id, 60 const std::string& md5_checksum, 61 bool conflicted, 62 bool to_be_fetched, 63 DriveMetadata_ResourceType file_type) { 64 DriveMetadata metadata; 65 metadata.set_resource_id(CreateResourceId(resource_id)); 66 metadata.set_md5_checksum(md5_checksum); 67 metadata.set_conflicted(conflicted); 68 metadata.set_to_be_fetched(to_be_fetched); 69 metadata.set_type(file_type); 70 return metadata; 71 } 72 73 } // namespace 74 75 class DriveMetadataStoreTest : public testing::Test { 76 public: 77 DriveMetadataStoreTest() 78 : created_(false) {} 79 80 virtual ~DriveMetadataStoreTest() {} 81 82 virtual void SetUp() OVERRIDE { 83 file_thread_.reset(new base::Thread("Thread_File")); 84 file_thread_->Start(); 85 86 ui_task_runner_ = base::MessageLoopProxy::current(); 87 file_task_runner_ = file_thread_->message_loop_proxy(); 88 89 ASSERT_TRUE(base_dir_.CreateUniqueTempDir()); 90 RegisterSyncableFileSystem(); 91 } 92 93 virtual void TearDown() OVERRIDE { 94 SetDisableDriveAPI(false); 95 RevokeSyncableFileSystem(); 96 97 DropDatabase(); 98 file_thread_->Stop(); 99 message_loop_.RunUntilIdle(); 100 } 101 102 protected: 103 void InitializeDatabase() { 104 EXPECT_TRUE(ui_task_runner_->RunsTasksOnCurrentThread()); 105 106 bool done = false; 107 SyncStatusCode status = SYNC_STATUS_UNKNOWN; 108 bool created = false; 109 110 drive_metadata_store_.reset( 111 new DriveMetadataStore(base_dir_.path(), file_task_runner_.get())); 112 drive_metadata_store_->Initialize( 113 base::Bind(&DriveMetadataStoreTest::DidInitializeDatabase, 114 base::Unretained(this), 115 &done, 116 &status, 117 &created)); 118 message_loop_.Run(); 119 120 EXPECT_TRUE(done); 121 EXPECT_EQ(SYNC_STATUS_OK, status); 122 123 if (created) { 124 EXPECT_FALSE(created_); 125 created_ = created; 126 return; 127 } 128 EXPECT_TRUE(created_); 129 } 130 131 void DropDatabase() { 132 EXPECT_TRUE(ui_task_runner_->RunsTasksOnCurrentThread()); 133 drive_metadata_store_.reset(); 134 } 135 136 SyncStatusCode EnableOrigin(const GURL& origin) { 137 SyncStatusCode status = SYNC_STATUS_UNKNOWN; 138 drive_metadata_store_->EnableOrigin( 139 origin, base::Bind(&DriveMetadataStoreTest::DidFinishDBTask, 140 base::Unretained(this), &status)); 141 message_loop_.Run(); 142 return status; 143 } 144 145 SyncStatusCode DisableOrigin(const GURL& origin) { 146 SyncStatusCode status = SYNC_STATUS_UNKNOWN; 147 drive_metadata_store_->DisableOrigin( 148 origin, base::Bind(&DriveMetadataStoreTest::DidFinishDBTask, 149 base::Unretained(this), &status)); 150 message_loop_.Run(); 151 return status; 152 } 153 154 SyncStatusCode RemoveOrigin(const GURL& url) { 155 SyncStatusCode status = SYNC_STATUS_UNKNOWN; 156 drive_metadata_store_->RemoveOrigin( 157 url, base::Bind(&DriveMetadataStoreTest::DidFinishDBTask, 158 base::Unretained(this), &status)); 159 message_loop_.Run(); 160 return status; 161 } 162 163 SyncStatusCode UpdateEntry(const fileapi::FileSystemURL& url, 164 const DriveMetadata& metadata) { 165 SyncStatusCode status = SYNC_STATUS_UNKNOWN; 166 drive_metadata_store_->UpdateEntry( 167 url, metadata, 168 base::Bind(&DriveMetadataStoreTest::DidFinishDBTask, 169 base::Unretained(this), &status)); 170 message_loop_.Run(); 171 return status; 172 } 173 174 SyncStatusCode DeleteEntry(const fileapi::FileSystemURL& url) { 175 SyncStatusCode status = SYNC_STATUS_UNKNOWN; 176 drive_metadata_store_->DeleteEntry( 177 url, 178 base::Bind(&DriveMetadataStoreTest::DidFinishDBTask, 179 base::Unretained(this), &status)); 180 message_loop_.Run(); 181 return status; 182 } 183 184 SyncStatusCode SetLargestChangeStamp(int64 changestamp) { 185 SyncStatusCode status = SYNC_STATUS_UNKNOWN; 186 drive_metadata_store_->SetLargestChangeStamp( 187 changestamp, base::Bind(&DriveMetadataStoreTest::DidFinishDBTask, 188 base::Unretained(this), &status)); 189 message_loop_.Run(); 190 return status; 191 } 192 193 void DidFinishDBTask(SyncStatusCode* status_out, 194 SyncStatusCode status) { 195 *status_out = status; 196 message_loop_.Quit(); 197 } 198 199 void MarkAsCreated() { 200 created_ = true; 201 } 202 203 void VerifyUntrackedOrigin(const GURL& origin) { 204 EXPECT_FALSE(metadata_store()->IsIncrementalSyncOrigin(origin)); 205 EXPECT_FALSE(metadata_store()->IsOriginDisabled(origin)); 206 } 207 208 void VerifyIncrementalSyncOrigin(const GURL& origin, 209 const std::string& resource_id) { 210 EXPECT_TRUE(metadata_store()->IsIncrementalSyncOrigin(origin)); 211 EXPECT_FALSE(metadata_store()->IsOriginDisabled(origin)); 212 EXPECT_EQ(resource_id, 213 GetResourceID(metadata_store()->incremental_sync_origins(), 214 origin)); 215 } 216 217 void VerifyDisabledOrigin(const GURL& origin, 218 const std::string& resource_id) { 219 EXPECT_FALSE(metadata_store()->IsIncrementalSyncOrigin(origin)); 220 EXPECT_TRUE(metadata_store()->IsOriginDisabled(origin)); 221 EXPECT_EQ(resource_id, 222 GetResourceID(metadata_store()->disabled_origins(), origin)); 223 } 224 225 base::FilePath base_dir() { 226 return base_dir_.path(); 227 } 228 229 DriveMetadataStore* metadata_store() { 230 return drive_metadata_store_.get(); 231 } 232 233 leveldb::DB* metadata_db() { 234 return drive_metadata_store_->GetDBInstanceForTesting(); 235 } 236 237 const DriveMetadataStore::MetadataMap& metadata_map() { 238 return drive_metadata_store_->metadata_map_; 239 } 240 241 void VerifyReverseMap() { 242 const ResourceIdByOrigin& incremental_sync_origins = 243 drive_metadata_store_->incremental_sync_origins_; 244 const ResourceIdByOrigin& disabled_origins = 245 drive_metadata_store_->disabled_origins_; 246 const OriginByResourceId& origin_by_resource_id = 247 drive_metadata_store_->origin_by_resource_id_; 248 249 size_t expected_size = incremental_sync_origins.size() + 250 disabled_origins.size(); 251 size_t actual_size = origin_by_resource_id.size(); 252 EXPECT_EQ(expected_size, actual_size); 253 EXPECT_TRUE(VerifyReverseMapInclusion(incremental_sync_origins, 254 origin_by_resource_id)); 255 EXPECT_TRUE(VerifyReverseMapInclusion(disabled_origins, 256 origin_by_resource_id)); 257 } 258 259 void ReadWrite_Body(); 260 void GetConflictURLs_Body(); 261 void GetToBeFetchedFiles_Body(); 262 void StoreSyncRootDirectory_Body(); 263 void StoreSyncOrigin_Body(); 264 void DisableOrigin_Body(); 265 void RemoveOrigin_Body(); 266 void GetResourceIdForOrigin_Body(); 267 void ResetOriginRootDirectory_Body(); 268 void GetFileMetadataMap_Body(); 269 270 private: 271 void DidInitializeDatabase(bool* done_out, 272 SyncStatusCode* status_out, 273 bool* created_out, 274 SyncStatusCode status, 275 bool created) { 276 *done_out = true; 277 *status_out = status; 278 *created_out = created; 279 message_loop_.Quit(); 280 } 281 282 bool VerifyReverseMapInclusion(const ResourceIdByOrigin& left, 283 const OriginByResourceId& right) { 284 for (ResourceIdByOrigin::const_iterator itr = left.begin(); 285 itr != left.end(); ++itr) { 286 OriginByResourceId::const_iterator found = right.find(itr->second); 287 if (found == right.end() || found->second != itr->first) 288 return false; 289 } 290 return true; 291 } 292 293 base::ScopedTempDir base_dir_; 294 295 base::MessageLoop message_loop_; 296 scoped_ptr<base::Thread> file_thread_; 297 298 scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_; 299 scoped_refptr<base::SequencedTaskRunner> file_task_runner_; 300 301 scoped_ptr<DriveMetadataStore> drive_metadata_store_; 302 303 bool created_; 304 305 DISALLOW_COPY_AND_ASSIGN(DriveMetadataStoreTest); 306 }; 307 308 void DriveMetadataStoreTest::ReadWrite_Body() { 309 InitializeDatabase(); 310 311 const fileapi::FileSystemURL url = URL(base::FilePath()); 312 DriveMetadata metadata; 313 EXPECT_EQ(SYNC_DATABASE_ERROR_NOT_FOUND, 314 metadata_store()->ReadEntry(url, &metadata)); 315 316 metadata = CreateMetadata( 317 "file:1234567890", "09876543210", true, false, 318 DriveMetadata_ResourceType_RESOURCE_TYPE_FILE); 319 EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(url, metadata)); 320 EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1)); 321 322 DropDatabase(); 323 InitializeDatabase(); 324 325 EXPECT_EQ(1, metadata_store()->GetLargestChangeStamp()); 326 327 DriveMetadata metadata2; 328 EXPECT_EQ(SYNC_STATUS_OK, 329 metadata_store()->ReadEntry(url, &metadata2)); 330 EXPECT_EQ(metadata.resource_id(), metadata2.resource_id()); 331 EXPECT_EQ(metadata.md5_checksum(), metadata2.md5_checksum()); 332 EXPECT_EQ(metadata.conflicted(), metadata2.conflicted()); 333 334 EXPECT_EQ(SYNC_STATUS_OK, DeleteEntry(url)); 335 EXPECT_EQ(SYNC_DATABASE_ERROR_NOT_FOUND, 336 metadata_store()->ReadEntry(url, &metadata)); 337 EXPECT_EQ(SYNC_DATABASE_ERROR_NOT_FOUND, DeleteEntry(url)); 338 339 VerifyReverseMap(); 340 } 341 342 void DriveMetadataStoreTest::GetConflictURLs_Body() { 343 InitializeDatabase(); 344 345 fileapi::FileSystemURLSet urls; 346 EXPECT_EQ(SYNC_STATUS_OK, metadata_store()->GetConflictURLs(&urls)); 347 EXPECT_EQ(0U, urls.size()); 348 349 const base::FilePath path1(FPL("file1")); 350 const base::FilePath path2(FPL("file2")); 351 const base::FilePath path3(FPL("file3")); 352 353 // Populate metadata in DriveMetadataStore. The metadata identified by "file2" 354 // and "file3" are marked as conflicted. 355 EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry( 356 URL(path1), 357 CreateMetadata("file:1", "1", false, false, 358 DriveMetadata_ResourceType_RESOURCE_TYPE_FILE))); 359 EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry( 360 URL(path2), 361 CreateMetadata("file:2", "2", true, false, 362 DriveMetadata_ResourceType_RESOURCE_TYPE_FILE))); 363 EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry( 364 URL(path3), 365 CreateMetadata("file:3", "3", true, false, 366 DriveMetadata_ResourceType_RESOURCE_TYPE_FILE))); 367 368 EXPECT_EQ(SYNC_STATUS_OK, metadata_store()->GetConflictURLs(&urls)); 369 EXPECT_EQ(2U, urls.size()); 370 EXPECT_FALSE(ContainsKey(urls, URL(path1))); 371 EXPECT_TRUE(ContainsKey(urls, URL(path2))); 372 EXPECT_TRUE(ContainsKey(urls, URL(path3))); 373 374 VerifyReverseMap(); 375 } 376 377 void DriveMetadataStoreTest::GetToBeFetchedFiles_Body() { 378 InitializeDatabase(); 379 380 DriveMetadataStore::URLAndDriveMetadataList list; 381 EXPECT_EQ(SYNC_STATUS_OK, metadata_store()->GetToBeFetchedFiles(&list)); 382 EXPECT_TRUE(list.empty()); 383 384 const base::FilePath path1(FPL("file1")); 385 const base::FilePath path2(FPL("file2")); 386 const base::FilePath path3(FPL("file3")); 387 388 // Populate metadata in DriveMetadataStore. The metadata identified by "file2" 389 // and "file3" are marked to be fetched. 390 EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry( 391 URL(path1), 392 CreateMetadata("file:1", "1", false, false, 393 DriveMetadata_ResourceType_RESOURCE_TYPE_FILE))); 394 EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry( 395 URL(path2), 396 CreateMetadata("file:2", "2", false, true, 397 DriveMetadata_ResourceType_RESOURCE_TYPE_FILE))); 398 EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry( 399 URL(path3), 400 CreateMetadata("file:3", "3", false, true, 401 DriveMetadata_ResourceType_RESOURCE_TYPE_FILE))); 402 403 EXPECT_EQ(SYNC_STATUS_OK, 404 metadata_store()->GetToBeFetchedFiles(&list)); 405 EXPECT_EQ(2U, list.size()); 406 EXPECT_EQ(list[0].first, URL(path2)); 407 EXPECT_EQ(list[1].first, URL(path3)); 408 409 VerifyReverseMap(); 410 } 411 412 void DriveMetadataStoreTest::StoreSyncRootDirectory_Body() { 413 const std::string kResourceId(CreateResourceId("folder:hoge")); 414 415 InitializeDatabase(); 416 EXPECT_TRUE(metadata_store()->sync_root_directory().empty()); 417 418 metadata_store()->SetSyncRootDirectory(kResourceId); 419 EXPECT_EQ(kResourceId, metadata_store()->sync_root_directory()); 420 421 DropDatabase(); 422 InitializeDatabase(); 423 EXPECT_EQ(kResourceId, metadata_store()->sync_root_directory()); 424 } 425 426 void DriveMetadataStoreTest::StoreSyncOrigin_Body() { 427 const GURL kOrigin1("chrome-extension://example1"); 428 const GURL kOrigin2("chrome-extension://example2"); 429 const std::string kResourceId1(CreateResourceId("folder:hoge")); 430 const std::string kResourceId2(CreateResourceId("folder:fuga")); 431 432 InitializeDatabase(); 433 434 // Make sure origins have not been marked yet. 435 VerifyUntrackedOrigin(kOrigin1); 436 VerifyUntrackedOrigin(kOrigin2); 437 438 // Mark origins as incremental sync origins. 439 metadata_store()->AddIncrementalSyncOrigin(kOrigin1, kResourceId1); 440 metadata_store()->AddIncrementalSyncOrigin(kOrigin2, kResourceId2); 441 VerifyIncrementalSyncOrigin(kOrigin1, kResourceId1); 442 VerifyIncrementalSyncOrigin(kOrigin2, kResourceId2); 443 444 // Disabled origin 2, origin 1 should still be incremental. 445 DisableOrigin(kOrigin2); 446 VerifyIncrementalSyncOrigin(kOrigin1, kResourceId1); 447 VerifyDisabledOrigin(kOrigin2, kResourceId2); 448 449 DropDatabase(); 450 InitializeDatabase(); 451 452 // Make sure origins have been restored. 453 VerifyIncrementalSyncOrigin(kOrigin1, kResourceId1); 454 VerifyDisabledOrigin(kOrigin2, kResourceId2); 455 456 VerifyReverseMap(); 457 } 458 459 void DriveMetadataStoreTest::DisableOrigin_Body() { 460 const GURL kOrigin1("chrome-extension://example1"); 461 const std::string kResourceId1(CreateResourceId("folder:hoge")); 462 463 InitializeDatabase(); 464 EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1)); 465 466 metadata_store()->AddIncrementalSyncOrigin(kOrigin1, kResourceId1); 467 VerifyIncrementalSyncOrigin(kOrigin1, kResourceId1); 468 469 DisableOrigin(kOrigin1); 470 VerifyDisabledOrigin(kOrigin1, kResourceId1); 471 472 // Re-enabled origins go back to DriveFileSyncService and are not tracked 473 // in DriveMetadataStore. 474 EnableOrigin(kOrigin1); 475 VerifyUntrackedOrigin(kOrigin1); 476 } 477 478 void DriveMetadataStoreTest::RemoveOrigin_Body() { 479 const GURL kOrigin1("chrome-extension://example1"); 480 const GURL kOrigin2("chrome-extension://example2"); 481 const GURL kOrigin3("chrome-extension://example3"); 482 const std::string kResourceId1(CreateResourceId("folder:hogera")); 483 const std::string kResourceId2(CreateResourceId("folder:fugaga")); 484 const std::string kResourceId3(CreateResourceId("folder:piyopiyo")); 485 486 InitializeDatabase(); 487 EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1)); 488 489 metadata_store()->AddIncrementalSyncOrigin(kOrigin1, kResourceId1); 490 metadata_store()->AddIncrementalSyncOrigin(kOrigin2, kResourceId2); 491 metadata_store()->AddIncrementalSyncOrigin(kOrigin3, kResourceId3); 492 DisableOrigin(kOrigin3); 493 EXPECT_EQ(2u, metadata_store()->incremental_sync_origins().size()); 494 EXPECT_EQ(1u, metadata_store()->disabled_origins().size()); 495 496 EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry( 497 CreateSyncableFileSystemURL(kOrigin1, base::FilePath(FPL("guf"))), 498 CreateMetadata("file:foo", "spam", false, false, 499 DriveMetadata_ResourceType_RESOURCE_TYPE_FILE))); 500 EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry( 501 CreateSyncableFileSystemURL(kOrigin2, base::FilePath(FPL("mof"))), 502 CreateMetadata("file:bar", "ham", false, false, 503 DriveMetadata_ResourceType_RESOURCE_TYPE_FILE))); 504 EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry( 505 CreateSyncableFileSystemURL(kOrigin3, base::FilePath(FPL("waf"))), 506 CreateMetadata("folder:baz", "egg", false, false, 507 DriveMetadata_ResourceType_RESOURCE_TYPE_FOLDER))); 508 509 EXPECT_EQ(SYNC_STATUS_OK, RemoveOrigin(kOrigin2)); 510 EXPECT_EQ(SYNC_STATUS_OK, RemoveOrigin(kOrigin3)); 511 512 DropDatabase(); 513 InitializeDatabase(); 514 515 // kOrigin1 should be the only one left. 516 EXPECT_EQ(1u, metadata_store()->incremental_sync_origins().size()); 517 EXPECT_EQ(0u, metadata_store()->disabled_origins().size()); 518 EXPECT_TRUE(metadata_store()->IsIncrementalSyncOrigin(kOrigin1)); 519 EXPECT_EQ(1u, metadata_map().size()); 520 521 DriveMetadataStore::MetadataMap::const_iterator found = 522 metadata_map().find(kOrigin1); 523 EXPECT_TRUE(found != metadata_map().end() && found->second.size() == 1u); 524 525 VerifyReverseMap(); 526 } 527 528 void DriveMetadataStoreTest::GetResourceIdForOrigin_Body() { 529 const GURL kOrigin1("chrome-extension://example1"); 530 const GURL kOrigin2("chrome-extension://example2"); 531 const GURL kOrigin3("chrome-extension://example3"); 532 const std::string kResourceId1(CreateResourceId("folder:hogera")); 533 const std::string kResourceId2(CreateResourceId("folder:fugaga")); 534 const std::string kResourceId3(CreateResourceId("folder:piyopiyo")); 535 536 InitializeDatabase(); 537 EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1)); 538 metadata_store()->SetSyncRootDirectory(CreateResourceId("folder:root")); 539 540 metadata_store()->AddIncrementalSyncOrigin(kOrigin1, kResourceId1); 541 metadata_store()->AddIncrementalSyncOrigin(kOrigin2, kResourceId2); 542 metadata_store()->AddIncrementalSyncOrigin(kOrigin3, kResourceId3); 543 DisableOrigin(kOrigin3); 544 545 EXPECT_EQ(kResourceId1, metadata_store()->GetResourceIdForOrigin(kOrigin1)); 546 EXPECT_EQ(kResourceId2, metadata_store()->GetResourceIdForOrigin(kOrigin2)); 547 EXPECT_EQ(kResourceId3, metadata_store()->GetResourceIdForOrigin(kOrigin3)); 548 549 DropDatabase(); 550 InitializeDatabase(); 551 552 EXPECT_EQ(kResourceId1, metadata_store()->GetResourceIdForOrigin(kOrigin1)); 553 EXPECT_EQ(kResourceId2, metadata_store()->GetResourceIdForOrigin(kOrigin2)); 554 EXPECT_EQ(kResourceId3, metadata_store()->GetResourceIdForOrigin(kOrigin3)); 555 556 // Resetting the root directory resource ID to empty makes any 557 // GetResourceIdForOrigin return an empty resource ID too, regardless of 558 // whether they are known origin or not. 559 metadata_store()->SetSyncRootDirectory(std::string()); 560 EXPECT_TRUE(metadata_store()->GetResourceIdForOrigin(kOrigin1).empty()); 561 EXPECT_TRUE(metadata_store()->GetResourceIdForOrigin(kOrigin2).empty()); 562 EXPECT_TRUE(metadata_store()->GetResourceIdForOrigin(kOrigin3).empty()); 563 564 // Make sure they're still known origins. 565 EXPECT_TRUE(metadata_store()->IsKnownOrigin(kOrigin1)); 566 EXPECT_TRUE(metadata_store()->IsKnownOrigin(kOrigin2)); 567 EXPECT_TRUE(metadata_store()->IsKnownOrigin(kOrigin3)); 568 569 VerifyReverseMap(); 570 } 571 572 void DriveMetadataStoreTest::ResetOriginRootDirectory_Body() { 573 const GURL kOrigin1("chrome-extension://example1"); 574 const std::string kResourceId1(CreateResourceId("folder:hoge")); 575 const std::string kResourceId2(CreateResourceId("folder:fuga")); 576 577 InitializeDatabase(); 578 EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1)); 579 580 metadata_store()->AddIncrementalSyncOrigin(kOrigin1, kResourceId1); 581 VerifyIncrementalSyncOrigin(kOrigin1, kResourceId1); 582 VerifyReverseMap(); 583 584 metadata_store()->SetOriginRootDirectory(kOrigin1, kResourceId2); 585 VerifyIncrementalSyncOrigin(kOrigin1, kResourceId2); 586 VerifyReverseMap(); 587 } 588 589 void DriveMetadataStoreTest::GetFileMetadataMap_Body() { 590 InitializeDatabase(); 591 592 // Save one file and folder to the origin. 593 const base::FilePath file_path = base::FilePath(FPL("file_0")); 594 const base::FilePath folder_path = base::FilePath(FPL("folder_0")); 595 596 const GURL origin = GURL("chrome-extension://app_a"); 597 const fileapi::FileSystemURL url_0 = CreateSyncableFileSystemURL( 598 origin, file_path); 599 const fileapi::FileSystemURL url_1 = CreateSyncableFileSystemURL( 600 origin, folder_path); 601 602 // Insert DrivaMetadata objects. 603 EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry( 604 url_0, 605 CreateMetadata("file:0", "1", false, false, 606 DriveMetadata_ResourceType_RESOURCE_TYPE_FILE))); 607 EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry( 608 url_1, 609 CreateMetadata("folder:0", "2", false, true, 610 DriveMetadata_ResourceType_RESOURCE_TYPE_FOLDER))); 611 612 // Check that DriveMetadata objects get mapped back to generalized 613 // FileMetadata objects. 614 scoped_ptr<base::ListValue> files = metadata_store()->DumpFiles(origin); 615 ASSERT_EQ(2u, files->GetSize()); 616 617 base::DictionaryValue* file = NULL; 618 std::string str; 619 620 ASSERT_TRUE(files->GetDictionary(0, &file)); 621 EXPECT_TRUE(file->GetString("title", &str) && str == "file_0"); 622 EXPECT_TRUE(file->GetString("type", &str) && str == "file"); 623 EXPECT_TRUE(file->HasKey("details")); 624 625 ASSERT_TRUE(files->GetDictionary(1, &file)); 626 EXPECT_TRUE(file->GetString("title", &str) && str == "folder_0"); 627 EXPECT_TRUE(file->GetString("type", &str) && str == "folder"); 628 EXPECT_TRUE(file->HasKey("details")); 629 } 630 631 TEST_F(DriveMetadataStoreTest, Initialization) { 632 ASSERT_FALSE(IsDriveAPIDisabled()); 633 InitializeDatabase(); 634 } 635 636 TEST_F(DriveMetadataStoreTest, Initialization_WAPI) { 637 SetDisableDriveAPI(true); 638 InitializeDatabase(); 639 } 640 641 TEST_F(DriveMetadataStoreTest, ReadWrite) { 642 ASSERT_FALSE(IsDriveAPIDisabled()); 643 ReadWrite_Body(); 644 } 645 646 TEST_F(DriveMetadataStoreTest, ReadWrite_WAPI) { 647 SetDisableDriveAPI(true); 648 ReadWrite_Body(); 649 } 650 651 TEST_F(DriveMetadataStoreTest, GetConflictURLs) { 652 ASSERT_FALSE(IsDriveAPIDisabled()); 653 GetConflictURLs_Body(); 654 } 655 656 TEST_F(DriveMetadataStoreTest, GetConflictURLs_WAPI) { 657 SetDisableDriveAPI(true); 658 GetConflictURLs_Body(); 659 } 660 661 TEST_F(DriveMetadataStoreTest, GetToBeFetchedFiles) { 662 ASSERT_FALSE(IsDriveAPIDisabled()); 663 GetToBeFetchedFiles_Body(); 664 } 665 666 TEST_F(DriveMetadataStoreTest, GetToBeFetchedFiles_WAPI) { 667 SetDisableDriveAPI(true); 668 GetToBeFetchedFiles_Body(); 669 } 670 671 TEST_F(DriveMetadataStoreTest, StoreSyncRootDirectory) { 672 ASSERT_FALSE(IsDriveAPIDisabled()); 673 StoreSyncRootDirectory_Body(); 674 } 675 676 TEST_F(DriveMetadataStoreTest, StoreSyncRootDirectory_WAPI) { 677 SetDisableDriveAPI(true); 678 StoreSyncRootDirectory_Body(); 679 } 680 681 TEST_F(DriveMetadataStoreTest, StoreSyncOrigin) { 682 ASSERT_FALSE(IsDriveAPIDisabled()); 683 StoreSyncOrigin_Body(); 684 } 685 686 TEST_F(DriveMetadataStoreTest, StoreSyncOrigin_WAPI) { 687 SetDisableDriveAPI(true); 688 StoreSyncOrigin_Body(); 689 } 690 691 TEST_F(DriveMetadataStoreTest, DisableOrigin) { 692 ASSERT_FALSE(IsDriveAPIDisabled()); 693 DisableOrigin_Body(); 694 } 695 696 TEST_F(DriveMetadataStoreTest, DisableOrigin_WAPI) { 697 SetDisableDriveAPI(true); 698 DisableOrigin_Body(); 699 } 700 701 TEST_F(DriveMetadataStoreTest, RemoveOrigin) { 702 ASSERT_FALSE(IsDriveAPIDisabled()); 703 RemoveOrigin_Body(); 704 } 705 706 TEST_F(DriveMetadataStoreTest, RemoveOrigin_WAPI) { 707 SetDisableDriveAPI(true); 708 RemoveOrigin_Body(); 709 } 710 711 TEST_F(DriveMetadataStoreTest, GetResourceIdForOrigin) { 712 ASSERT_FALSE(IsDriveAPIDisabled()); 713 GetResourceIdForOrigin_Body(); 714 } 715 716 TEST_F(DriveMetadataStoreTest, GetResourceIdForOrigin_WAPI) { 717 SetDisableDriveAPI(true); 718 GetResourceIdForOrigin_Body(); 719 } 720 721 TEST_F(DriveMetadataStoreTest, ResetOriginRootDirectory) { 722 ASSERT_FALSE(IsDriveAPIDisabled()); 723 ResetOriginRootDirectory_Body(); 724 } 725 726 TEST_F(DriveMetadataStoreTest, ResetOriginRootDirectory_WAPI) { 727 SetDisableDriveAPI(true); 728 ResetOriginRootDirectory_Body(); 729 } 730 731 TEST_F(DriveMetadataStoreTest, GetFileMetadataMap) { 732 ASSERT_FALSE(IsDriveAPIDisabled()); 733 GetFileMetadataMap_Body(); 734 } 735 736 TEST_F(DriveMetadataStoreTest, GetFileMetadataMap_WAPI) { 737 SetDisableDriveAPI(true); 738 GetFileMetadataMap_Body(); 739 } 740 741 } // namespace sync_file_system 742
