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 "chrome/browser/drive/fake_drive_service.h" 6 7 #include <string> 8 #include <vector> 9 10 #include "base/file_util.h" 11 #include "base/files/scoped_temp_dir.h" 12 #include "base/md5.h" 13 #include "base/run_loop.h" 14 #include "base/stl_util.h" 15 #include "base/strings/stringprintf.h" 16 #include "base/strings/utf_string_conversions.h" 17 #include "content/public/test/test_browser_thread_bundle.h" 18 #include "google_apis/drive/drive_api_parser.h" 19 #include "google_apis/drive/gdata_wapi_parser.h" 20 #include "google_apis/drive/gdata_wapi_requests.h" 21 #include "google_apis/drive/test_util.h" 22 #include "testing/gtest/include/gtest/gtest.h" 23 24 using google_apis::AboutResource; 25 using google_apis::AppList; 26 using google_apis::GDataErrorCode; 27 using google_apis::GDATA_NO_CONNECTION; 28 using google_apis::GDATA_OTHER_ERROR; 29 using google_apis::GetContentCallback; 30 using google_apis::HTTP_CREATED; 31 using google_apis::HTTP_NOT_FOUND; 32 using google_apis::HTTP_NO_CONTENT; 33 using google_apis::HTTP_PRECONDITION; 34 using google_apis::HTTP_RESUME_INCOMPLETE; 35 using google_apis::HTTP_SUCCESS; 36 using google_apis::Link; 37 using google_apis::ProgressCallback; 38 using google_apis::ResourceEntry; 39 using google_apis::ResourceList; 40 using google_apis::UploadRangeResponse; 41 namespace test_util = google_apis::test_util; 42 43 namespace drive { 44 45 namespace { 46 47 class FakeDriveServiceTest : public testing::Test { 48 protected: 49 // Returns the resource entry that matches |resource_id|. 50 scoped_ptr<ResourceEntry> FindEntry(const std::string& resource_id) { 51 GDataErrorCode error = GDATA_OTHER_ERROR; 52 scoped_ptr<ResourceEntry> resource_entry; 53 fake_service_.GetResourceEntry( 54 resource_id, 55 test_util::CreateCopyResultCallback(&error, &resource_entry)); 56 base::RunLoop().RunUntilIdle(); 57 return resource_entry.Pass(); 58 } 59 60 // Returns true if the resource identified by |resource_id| exists. 61 bool Exists(const std::string& resource_id) { 62 scoped_ptr<ResourceEntry> resource_entry = FindEntry(resource_id); 63 return resource_entry && !resource_entry->deleted(); 64 } 65 66 // Adds a new directory at |parent_resource_id| with the given name. 67 // Returns true on success. 68 bool AddNewDirectory(const std::string& parent_resource_id, 69 const std::string& directory_title) { 70 GDataErrorCode error = GDATA_OTHER_ERROR; 71 scoped_ptr<ResourceEntry> resource_entry; 72 fake_service_.AddNewDirectory( 73 parent_resource_id, 74 directory_title, 75 test_util::CreateCopyResultCallback(&error, &resource_entry)); 76 base::RunLoop().RunUntilIdle(); 77 return error == HTTP_CREATED; 78 } 79 80 // Returns true if the resource identified by |resource_id| has a parent 81 // identified by |parent_id|. 82 bool HasParent(const std::string& resource_id, const std::string& parent_id) { 83 const GURL parent_url = FakeDriveService::GetFakeLinkUrl(parent_id); 84 scoped_ptr<ResourceEntry> resource_entry = FindEntry(resource_id); 85 if (resource_entry.get()) { 86 for (size_t i = 0; i < resource_entry->links().size(); ++i) { 87 if (resource_entry->links()[i]->type() == Link::LINK_PARENT && 88 resource_entry->links()[i]->href() == parent_url) 89 return true; 90 } 91 } 92 return false; 93 } 94 95 int64 GetLargestChangeByAboutResource() { 96 GDataErrorCode error; 97 scoped_ptr<AboutResource> about_resource; 98 fake_service_.GetAboutResource( 99 test_util::CreateCopyResultCallback(&error, &about_resource)); 100 base::RunLoop().RunUntilIdle(); 101 return about_resource->largest_change_id(); 102 } 103 104 content::TestBrowserThreadBundle thread_bundle_; 105 FakeDriveService fake_service_; 106 }; 107 108 TEST_F(FakeDriveServiceTest, GetAllResourceList) { 109 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 110 "gdata/root_feed.json")); 111 112 GDataErrorCode error = GDATA_OTHER_ERROR; 113 scoped_ptr<ResourceList> resource_list; 114 fake_service_.GetAllResourceList( 115 test_util::CreateCopyResultCallback(&error, &resource_list)); 116 base::RunLoop().RunUntilIdle(); 117 118 EXPECT_EQ(HTTP_SUCCESS, error); 119 ASSERT_TRUE(resource_list); 120 // Do some sanity check. 121 EXPECT_EQ(14U, resource_list->entries().size()); 122 EXPECT_EQ(1, fake_service_.resource_list_load_count()); 123 } 124 125 TEST_F(FakeDriveServiceTest, GetAllResourceList_Offline) { 126 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 127 "gdata/root_feed.json")); 128 fake_service_.set_offline(true); 129 130 GDataErrorCode error = GDATA_OTHER_ERROR; 131 scoped_ptr<ResourceList> resource_list; 132 fake_service_.GetAllResourceList( 133 test_util::CreateCopyResultCallback(&error, &resource_list)); 134 base::RunLoop().RunUntilIdle(); 135 136 EXPECT_EQ(GDATA_NO_CONNECTION, error); 137 EXPECT_FALSE(resource_list); 138 } 139 140 TEST_F(FakeDriveServiceTest, GetResourceListInDirectory_InRootDirectory) { 141 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 142 "gdata/root_feed.json")); 143 144 GDataErrorCode error = GDATA_OTHER_ERROR; 145 scoped_ptr<ResourceList> resource_list; 146 fake_service_.GetResourceListInDirectory( 147 fake_service_.GetRootResourceId(), 148 test_util::CreateCopyResultCallback(&error, &resource_list)); 149 base::RunLoop().RunUntilIdle(); 150 151 EXPECT_EQ(HTTP_SUCCESS, error); 152 ASSERT_TRUE(resource_list); 153 // Do some sanity check. There are 8 entries in the root directory. 154 EXPECT_EQ(8U, resource_list->entries().size()); 155 EXPECT_EQ(1, fake_service_.directory_load_count()); 156 } 157 158 TEST_F(FakeDriveServiceTest, GetResourceListInDirectory_InNonRootDirectory) { 159 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 160 "gdata/root_feed.json")); 161 162 GDataErrorCode error = GDATA_OTHER_ERROR; 163 scoped_ptr<ResourceList> resource_list; 164 fake_service_.GetResourceListInDirectory( 165 "folder:1_folder_resource_id", 166 test_util::CreateCopyResultCallback(&error, &resource_list)); 167 base::RunLoop().RunUntilIdle(); 168 169 EXPECT_EQ(HTTP_SUCCESS, error); 170 ASSERT_TRUE(resource_list); 171 // Do some sanity check. There is three entries in 1_folder_resource_id 172 // directory. 173 EXPECT_EQ(3U, resource_list->entries().size()); 174 EXPECT_EQ(1, fake_service_.directory_load_count()); 175 } 176 177 TEST_F(FakeDriveServiceTest, GetResourceListInDirectory_Offline) { 178 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 179 "gdata/root_feed.json")); 180 fake_service_.set_offline(true); 181 182 GDataErrorCode error = GDATA_OTHER_ERROR; 183 scoped_ptr<ResourceList> resource_list; 184 fake_service_.GetResourceListInDirectory( 185 fake_service_.GetRootResourceId(), 186 test_util::CreateCopyResultCallback(&error, &resource_list)); 187 base::RunLoop().RunUntilIdle(); 188 189 EXPECT_EQ(GDATA_NO_CONNECTION, error); 190 EXPECT_FALSE(resource_list); 191 } 192 193 TEST_F(FakeDriveServiceTest, Search) { 194 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 195 "gdata/root_feed.json")); 196 197 GDataErrorCode error = GDATA_OTHER_ERROR; 198 scoped_ptr<ResourceList> resource_list; 199 fake_service_.Search( 200 "File", // search_query 201 test_util::CreateCopyResultCallback(&error, &resource_list)); 202 base::RunLoop().RunUntilIdle(); 203 204 EXPECT_EQ(HTTP_SUCCESS, error); 205 ASSERT_TRUE(resource_list); 206 // Do some sanity check. There are 4 entries that contain "File" in their 207 // titles. 208 EXPECT_EQ(4U, resource_list->entries().size()); 209 } 210 211 TEST_F(FakeDriveServiceTest, Search_WithAttribute) { 212 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 213 "gdata/root_feed.json")); 214 215 GDataErrorCode error = GDATA_OTHER_ERROR; 216 scoped_ptr<ResourceList> resource_list; 217 fake_service_.Search( 218 "title:1.txt", // search_query 219 test_util::CreateCopyResultCallback(&error, &resource_list)); 220 base::RunLoop().RunUntilIdle(); 221 222 EXPECT_EQ(HTTP_SUCCESS, error); 223 ASSERT_TRUE(resource_list); 224 // Do some sanity check. There are 4 entries that contain "1.txt" in their 225 // titles. 226 EXPECT_EQ(4U, resource_list->entries().size()); 227 } 228 229 TEST_F(FakeDriveServiceTest, Search_MultipleQueries) { 230 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 231 "gdata/root_feed.json")); 232 233 GDataErrorCode error = GDATA_OTHER_ERROR; 234 scoped_ptr<ResourceList> resource_list; 235 fake_service_.Search( 236 "Directory 1", // search_query 237 test_util::CreateCopyResultCallback(&error, &resource_list)); 238 base::RunLoop().RunUntilIdle(); 239 240 EXPECT_EQ(HTTP_SUCCESS, error); 241 ASSERT_TRUE(resource_list); 242 // There are 2 entries that contain both "Directory" and "1" in their titles. 243 EXPECT_EQ(2U, resource_list->entries().size()); 244 245 fake_service_.Search( 246 "\"Directory 1\"", // search_query 247 test_util::CreateCopyResultCallback(&error, &resource_list)); 248 base::RunLoop().RunUntilIdle(); 249 250 EXPECT_EQ(HTTP_SUCCESS, error); 251 ASSERT_TRUE(resource_list); 252 // There is 1 entry that contain "Directory 1" in its title. 253 EXPECT_EQ(1U, resource_list->entries().size()); 254 } 255 256 TEST_F(FakeDriveServiceTest, Search_Offline) { 257 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 258 "gdata/root_feed.json")); 259 fake_service_.set_offline(true); 260 261 GDataErrorCode error = GDATA_OTHER_ERROR; 262 scoped_ptr<ResourceList> resource_list; 263 fake_service_.Search( 264 "Directory 1", // search_query 265 test_util::CreateCopyResultCallback(&error, &resource_list)); 266 base::RunLoop().RunUntilIdle(); 267 268 EXPECT_EQ(GDATA_NO_CONNECTION, error); 269 EXPECT_FALSE(resource_list); 270 } 271 272 TEST_F(FakeDriveServiceTest, Search_Deleted) { 273 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 274 "gdata/root_feed.json")); 275 276 GDataErrorCode error = GDATA_OTHER_ERROR; 277 fake_service_.DeleteResource("file:2_file_resource_id", 278 std::string(), // etag 279 test_util::CreateCopyResultCallback(&error)); 280 base::RunLoop().RunUntilIdle(); 281 EXPECT_EQ(HTTP_NO_CONTENT, error); 282 283 error = GDATA_OTHER_ERROR; 284 scoped_ptr<ResourceList> resource_list; 285 fake_service_.Search( 286 "File", // search_query 287 test_util::CreateCopyResultCallback(&error, &resource_list)); 288 base::RunLoop().RunUntilIdle(); 289 290 EXPECT_EQ(HTTP_SUCCESS, error); 291 ASSERT_TRUE(resource_list); 292 // Do some sanity check. There are 4 entries that contain "File" in their 293 // titles and one of them is deleted. 294 EXPECT_EQ(3U, resource_list->entries().size()); 295 } 296 297 TEST_F(FakeDriveServiceTest, Search_Trashed) { 298 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 299 "gdata/root_feed.json")); 300 301 GDataErrorCode error = GDATA_OTHER_ERROR; 302 fake_service_.TrashResource("file:2_file_resource_id", 303 test_util::CreateCopyResultCallback(&error)); 304 base::RunLoop().RunUntilIdle(); 305 EXPECT_EQ(HTTP_SUCCESS, error); 306 307 error = GDATA_OTHER_ERROR; 308 scoped_ptr<ResourceList> resource_list; 309 fake_service_.Search( 310 "File", // search_query 311 test_util::CreateCopyResultCallback(&error, &resource_list)); 312 base::RunLoop().RunUntilIdle(); 313 314 EXPECT_EQ(HTTP_SUCCESS, error); 315 ASSERT_TRUE(resource_list); 316 // Do some sanity check. There are 4 entries that contain "File" in their 317 // titles and one of them is deleted. 318 EXPECT_EQ(3U, resource_list->entries().size()); 319 } 320 321 TEST_F(FakeDriveServiceTest, SearchByTitle) { 322 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 323 "gdata/root_feed.json")); 324 325 GDataErrorCode error = GDATA_OTHER_ERROR; 326 scoped_ptr<ResourceList> resource_list; 327 fake_service_.SearchByTitle( 328 "1.txt", // title 329 fake_service_.GetRootResourceId(), // directory_resource_id 330 test_util::CreateCopyResultCallback(&error, &resource_list)); 331 base::RunLoop().RunUntilIdle(); 332 333 EXPECT_EQ(HTTP_SUCCESS, error); 334 ASSERT_TRUE(resource_list); 335 // Do some sanity check. There are 2 entries that contain "1.txt" in their 336 // titles directly under the root directory. 337 EXPECT_EQ(2U, resource_list->entries().size()); 338 } 339 340 TEST_F(FakeDriveServiceTest, SearchByTitle_EmptyDirectoryResourceId) { 341 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 342 "gdata/root_feed.json")); 343 344 GDataErrorCode error = GDATA_OTHER_ERROR; 345 scoped_ptr<ResourceList> resource_list; 346 fake_service_.SearchByTitle( 347 "1.txt", // title 348 "", // directory resource id 349 test_util::CreateCopyResultCallback(&error, &resource_list)); 350 base::RunLoop().RunUntilIdle(); 351 352 EXPECT_EQ(HTTP_SUCCESS, error); 353 ASSERT_TRUE(resource_list); 354 // Do some sanity check. There are 4 entries that contain "1.txt" in their 355 // titles. 356 EXPECT_EQ(4U, resource_list->entries().size()); 357 } 358 359 TEST_F(FakeDriveServiceTest, SearchByTitle_Offline) { 360 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 361 "gdata/root_feed.json")); 362 fake_service_.set_offline(true); 363 364 GDataErrorCode error = GDATA_OTHER_ERROR; 365 scoped_ptr<ResourceList> resource_list; 366 fake_service_.SearchByTitle( 367 "Directory 1", // title 368 fake_service_.GetRootResourceId(), // directory_resource_id 369 test_util::CreateCopyResultCallback(&error, &resource_list)); 370 base::RunLoop().RunUntilIdle(); 371 372 EXPECT_EQ(GDATA_NO_CONNECTION, error); 373 EXPECT_FALSE(resource_list); 374 } 375 376 TEST_F(FakeDriveServiceTest, GetChangeList_NoNewEntries) { 377 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 378 "gdata/root_feed.json")); 379 // Load the account_metadata.json as well to add the largest changestamp 380 // (654321) to the existing entries. 381 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 382 "gdata/account_metadata.json")); 383 384 GDataErrorCode error = GDATA_OTHER_ERROR; 385 scoped_ptr<ResourceList> resource_list; 386 fake_service_.GetChangeList( 387 654321 + 1, // start_changestamp 388 test_util::CreateCopyResultCallback(&error, &resource_list)); 389 base::RunLoop().RunUntilIdle(); 390 391 EXPECT_EQ(HTTP_SUCCESS, error); 392 ASSERT_TRUE(resource_list); 393 EXPECT_EQ(fake_service_.largest_changestamp(), 394 resource_list->largest_changestamp()); 395 // This should be empty as the latest changestamp was passed to 396 // GetResourceList(), hence there should be no new entries. 397 EXPECT_EQ(0U, resource_list->entries().size()); 398 // It's considered loaded even if the result is empty. 399 EXPECT_EQ(1, fake_service_.change_list_load_count()); 400 } 401 402 TEST_F(FakeDriveServiceTest, GetChangeList_WithNewEntry) { 403 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 404 "gdata/root_feed.json")); 405 // Load the account_metadata.json as well to add the largest changestamp 406 // (654321) to the existing entries. 407 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 408 "gdata/account_metadata.json")); 409 // Add a new directory in the root directory. The new directory will have 410 // the changestamp of 654322. 411 ASSERT_TRUE(AddNewDirectory( 412 fake_service_.GetRootResourceId(), "new directory")); 413 414 // Get the resource list newer than 654321. 415 GDataErrorCode error = GDATA_OTHER_ERROR; 416 scoped_ptr<ResourceList> resource_list; 417 fake_service_.GetChangeList( 418 654321 + 1, // start_changestamp 419 test_util::CreateCopyResultCallback(&error, &resource_list)); 420 base::RunLoop().RunUntilIdle(); 421 422 EXPECT_EQ(HTTP_SUCCESS, error); 423 ASSERT_TRUE(resource_list); 424 EXPECT_EQ(fake_service_.largest_changestamp(), 425 resource_list->largest_changestamp()); 426 // The result should only contain the newly created directory. 427 ASSERT_EQ(1U, resource_list->entries().size()); 428 EXPECT_EQ("new directory", resource_list->entries()[0]->title()); 429 EXPECT_EQ(1, fake_service_.change_list_load_count()); 430 } 431 432 TEST_F(FakeDriveServiceTest, GetChangeList_Offline) { 433 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 434 "gdata/root_feed.json")); 435 fake_service_.set_offline(true); 436 437 GDataErrorCode error = GDATA_OTHER_ERROR; 438 scoped_ptr<ResourceList> resource_list; 439 fake_service_.GetChangeList( 440 654321, // start_changestamp 441 test_util::CreateCopyResultCallback(&error, &resource_list)); 442 base::RunLoop().RunUntilIdle(); 443 444 EXPECT_EQ(GDATA_NO_CONNECTION, error); 445 EXPECT_FALSE(resource_list); 446 } 447 448 TEST_F(FakeDriveServiceTest, GetChangeList_DeletedEntry) { 449 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 450 "gdata/root_feed.json")); 451 // Load the account_metadata.json as well to add the largest changestamp 452 // (654321) to the existing entries. 453 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 454 "gdata/account_metadata.json")); 455 ASSERT_TRUE(Exists("file:2_file_resource_id")); 456 457 GDataErrorCode error = GDATA_OTHER_ERROR; 458 fake_service_.DeleteResource("file:2_file_resource_id", 459 std::string(), // etag 460 test_util::CreateCopyResultCallback(&error)); 461 base::RunLoop().RunUntilIdle(); 462 ASSERT_EQ(HTTP_NO_CONTENT, error); 463 ASSERT_FALSE(Exists("file:2_file_resource_id")); 464 465 // Get the resource list newer than 654321. 466 error = GDATA_OTHER_ERROR; 467 scoped_ptr<ResourceList> resource_list; 468 fake_service_.GetChangeList( 469 654321 + 1, // start_changestamp 470 test_util::CreateCopyResultCallback(&error, &resource_list)); 471 base::RunLoop().RunUntilIdle(); 472 473 EXPECT_EQ(HTTP_SUCCESS, error); 474 ASSERT_TRUE(resource_list); 475 EXPECT_EQ(fake_service_.largest_changestamp(), 476 resource_list->largest_changestamp()); 477 // The result should only contain the deleted file. 478 ASSERT_EQ(1U, resource_list->entries().size()); 479 const ResourceEntry& entry = *resource_list->entries()[0]; 480 EXPECT_EQ("file:2_file_resource_id", entry.resource_id()); 481 EXPECT_TRUE(entry.title().empty()); 482 EXPECT_TRUE(entry.deleted()); 483 EXPECT_EQ(1, fake_service_.change_list_load_count()); 484 } 485 486 TEST_F(FakeDriveServiceTest, GetChangeList_TrashedEntry) { 487 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 488 "gdata/root_feed.json")); 489 // Load the account_metadata.json as well to add the largest changestamp 490 // (654321) to the existing entries. 491 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 492 "gdata/account_metadata.json")); 493 ASSERT_TRUE(Exists("file:2_file_resource_id")); 494 495 GDataErrorCode error = GDATA_OTHER_ERROR; 496 fake_service_.TrashResource("file:2_file_resource_id", 497 test_util::CreateCopyResultCallback(&error)); 498 base::RunLoop().RunUntilIdle(); 499 ASSERT_EQ(HTTP_SUCCESS, error); 500 ASSERT_FALSE(Exists("file:2_file_resource_id")); 501 502 // Get the resource list newer than 654321. 503 error = GDATA_OTHER_ERROR; 504 scoped_ptr<ResourceList> resource_list; 505 fake_service_.GetChangeList( 506 654321 + 1, // start_changestamp 507 test_util::CreateCopyResultCallback(&error, &resource_list)); 508 base::RunLoop().RunUntilIdle(); 509 510 EXPECT_EQ(HTTP_SUCCESS, error); 511 ASSERT_TRUE(resource_list); 512 EXPECT_EQ(fake_service_.largest_changestamp(), 513 resource_list->largest_changestamp()); 514 // The result should only contain the trashed file. 515 ASSERT_EQ(1U, resource_list->entries().size()); 516 const ResourceEntry& entry = *resource_list->entries()[0]; 517 EXPECT_EQ("file:2_file_resource_id", entry.resource_id()); 518 EXPECT_TRUE(entry.deleted()); 519 EXPECT_EQ(1, fake_service_.change_list_load_count()); 520 } 521 522 TEST_F(FakeDriveServiceTest, GetRemainingChangeList_GetAllResourceList) { 523 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 524 "gdata/root_feed.json")); 525 fake_service_.set_default_max_results(6); 526 527 GDataErrorCode error = GDATA_OTHER_ERROR; 528 scoped_ptr<ResourceList> resource_list; 529 fake_service_.GetAllResourceList( 530 test_util::CreateCopyResultCallback(&error, &resource_list)); 531 base::RunLoop().RunUntilIdle(); 532 EXPECT_EQ(HTTP_SUCCESS, error); 533 ASSERT_TRUE(resource_list); 534 535 // Do some sanity check. 536 // The number of results is 14 entries. Thus, it should split into three 537 // chunks: 6, 6, and then 2. 538 EXPECT_EQ(6U, resource_list->entries().size()); 539 EXPECT_EQ(1, fake_service_.resource_list_load_count()); 540 541 // Second page loading. 542 const google_apis::Link* next_link = 543 resource_list->GetLinkByType(Link::LINK_NEXT); 544 ASSERT_TRUE(next_link); 545 // Keep the next url before releasing the |resource_list|. 546 GURL next_url(next_link->href()); 547 548 error = GDATA_OTHER_ERROR; 549 resource_list.reset(); 550 fake_service_.GetRemainingChangeList( 551 next_url, 552 test_util::CreateCopyResultCallback(&error, &resource_list)); 553 base::RunLoop().RunUntilIdle(); 554 555 EXPECT_EQ(HTTP_SUCCESS, error); 556 ASSERT_TRUE(resource_list); 557 558 EXPECT_EQ(6U, resource_list->entries().size()); 559 EXPECT_EQ(1, fake_service_.resource_list_load_count()); 560 561 // Third page loading. 562 next_link = resource_list->GetLinkByType(Link::LINK_NEXT); 563 ASSERT_TRUE(next_link); 564 next_url = GURL(next_link->href()); 565 566 error = GDATA_OTHER_ERROR; 567 resource_list.reset(); 568 fake_service_.GetRemainingChangeList( 569 next_url, 570 test_util::CreateCopyResultCallback(&error, &resource_list)); 571 base::RunLoop().RunUntilIdle(); 572 573 EXPECT_EQ(HTTP_SUCCESS, error); 574 ASSERT_TRUE(resource_list); 575 576 EXPECT_EQ(2U, resource_list->entries().size()); 577 EXPECT_EQ(1, fake_service_.resource_list_load_count()); 578 } 579 580 TEST_F(FakeDriveServiceTest, 581 GetRemainingFileList_GetResourceListInDirectory) { 582 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 583 "gdata/root_feed.json")); 584 fake_service_.set_default_max_results(3); 585 586 GDataErrorCode error = GDATA_OTHER_ERROR; 587 scoped_ptr<ResourceList> resource_list; 588 fake_service_.GetResourceListInDirectory( 589 fake_service_.GetRootResourceId(), 590 test_util::CreateCopyResultCallback(&error, &resource_list)); 591 base::RunLoop().RunUntilIdle(); 592 EXPECT_EQ(HTTP_SUCCESS, error); 593 ASSERT_TRUE(resource_list); 594 595 // Do some sanity check. 596 // The number of results is 8 entries. Thus, it should split into three 597 // chunks: 3, 3, and then 2. 598 EXPECT_EQ(3U, resource_list->entries().size()); 599 EXPECT_EQ(1, fake_service_.directory_load_count()); 600 601 // Second page loading. 602 const google_apis::Link* next_link = 603 resource_list->GetLinkByType(Link::LINK_NEXT); 604 ASSERT_TRUE(next_link); 605 // Keep the next url before releasing the |resource_list|. 606 GURL next_url(next_link->href()); 607 608 error = GDATA_OTHER_ERROR; 609 resource_list.reset(); 610 fake_service_.GetRemainingFileList( 611 next_url, 612 test_util::CreateCopyResultCallback(&error, &resource_list)); 613 base::RunLoop().RunUntilIdle(); 614 615 EXPECT_EQ(HTTP_SUCCESS, error); 616 ASSERT_TRUE(resource_list); 617 618 EXPECT_EQ(3U, resource_list->entries().size()); 619 EXPECT_EQ(1, fake_service_.directory_load_count()); 620 621 // Third page loading. 622 next_link = resource_list->GetLinkByType(Link::LINK_NEXT); 623 ASSERT_TRUE(next_link); 624 next_url = GURL(next_link->href()); 625 626 error = GDATA_OTHER_ERROR; 627 resource_list.reset(); 628 fake_service_.GetRemainingFileList( 629 next_url, 630 test_util::CreateCopyResultCallback(&error, &resource_list)); 631 base::RunLoop().RunUntilIdle(); 632 633 EXPECT_EQ(HTTP_SUCCESS, error); 634 ASSERT_TRUE(resource_list); 635 636 EXPECT_EQ(2U, resource_list->entries().size()); 637 EXPECT_EQ(1, fake_service_.directory_load_count()); 638 } 639 640 TEST_F(FakeDriveServiceTest, GetRemainingFileList_Search) { 641 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 642 "gdata/root_feed.json")); 643 fake_service_.set_default_max_results(2); 644 645 GDataErrorCode error = GDATA_OTHER_ERROR; 646 scoped_ptr<ResourceList> resource_list; 647 fake_service_.Search( 648 "File", // search_query 649 test_util::CreateCopyResultCallback(&error, &resource_list)); 650 base::RunLoop().RunUntilIdle(); 651 EXPECT_EQ(HTTP_SUCCESS, error); 652 ASSERT_TRUE(resource_list); 653 654 // Do some sanity check. 655 // The number of results is 4 entries. Thus, it should split into two 656 // chunks: 2, and then 2 657 EXPECT_EQ(2U, resource_list->entries().size()); 658 659 // Second page loading. 660 const google_apis::Link* next_link = 661 resource_list->GetLinkByType(Link::LINK_NEXT); 662 ASSERT_TRUE(next_link); 663 // Keep the next url before releasing the |resource_list|. 664 GURL next_url(next_link->href()); 665 666 error = GDATA_OTHER_ERROR; 667 resource_list.reset(); 668 fake_service_.GetRemainingFileList( 669 next_url, 670 test_util::CreateCopyResultCallback(&error, &resource_list)); 671 base::RunLoop().RunUntilIdle(); 672 673 EXPECT_EQ(HTTP_SUCCESS, error); 674 ASSERT_TRUE(resource_list); 675 676 EXPECT_EQ(2U, resource_list->entries().size()); 677 } 678 679 TEST_F(FakeDriveServiceTest, GetRemainingChangeList_GetChangeList) { 680 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 681 "gdata/root_feed.json")); 682 fake_service_.set_default_max_results(2); 683 684 // Load the account_metadata.json as well to add the largest changestamp 685 // (654321) to the existing entries. 686 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 687 "gdata/account_metadata.json")); 688 // Add 5 new directory in the root directory. The new directory will have 689 // the changestamp of 654326. 690 for (int i = 0; i < 5; ++i) { 691 ASSERT_TRUE(AddNewDirectory( 692 fake_service_.GetRootResourceId(), 693 base::StringPrintf("new directory %d", i))); 694 } 695 696 GDataErrorCode error = GDATA_OTHER_ERROR; 697 scoped_ptr<ResourceList> resource_list; 698 fake_service_.GetChangeList( 699 654321 + 1, // start_changestamp 700 test_util::CreateCopyResultCallback(&error, &resource_list)); 701 base::RunLoop().RunUntilIdle(); 702 EXPECT_EQ(HTTP_SUCCESS, error); 703 ASSERT_TRUE(resource_list); 704 705 // Do some sanity check. 706 // The number of results is 5 entries. Thus, it should split into three 707 // chunks: 2, 2 and then 1. 708 EXPECT_EQ(2U, resource_list->entries().size()); 709 EXPECT_EQ(1, fake_service_.change_list_load_count()); 710 711 // Second page loading. 712 const google_apis::Link* next_link = 713 resource_list->GetLinkByType(Link::LINK_NEXT); 714 ASSERT_TRUE(next_link); 715 // Keep the next url before releasing the |resource_list|. 716 GURL next_url(next_link->href()); 717 718 error = GDATA_OTHER_ERROR; 719 resource_list.reset(); 720 fake_service_.GetRemainingChangeList( 721 next_url, 722 test_util::CreateCopyResultCallback(&error, &resource_list)); 723 base::RunLoop().RunUntilIdle(); 724 725 EXPECT_EQ(HTTP_SUCCESS, error); 726 ASSERT_TRUE(resource_list); 727 728 EXPECT_EQ(2U, resource_list->entries().size()); 729 EXPECT_EQ(1, fake_service_.change_list_load_count()); 730 731 // Third page loading. 732 next_link = resource_list->GetLinkByType(Link::LINK_NEXT); 733 ASSERT_TRUE(next_link); 734 next_url = GURL(next_link->href()); 735 736 error = GDATA_OTHER_ERROR; 737 resource_list.reset(); 738 fake_service_.GetRemainingChangeList( 739 next_url, 740 test_util::CreateCopyResultCallback(&error, &resource_list)); 741 base::RunLoop().RunUntilIdle(); 742 743 EXPECT_EQ(HTTP_SUCCESS, error); 744 ASSERT_TRUE(resource_list); 745 746 EXPECT_EQ(1U, resource_list->entries().size()); 747 EXPECT_EQ(1, fake_service_.change_list_load_count()); 748 } 749 750 TEST_F(FakeDriveServiceTest, GetAboutResource) { 751 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 752 "gdata/account_metadata.json")); 753 754 GDataErrorCode error = GDATA_OTHER_ERROR; 755 scoped_ptr<AboutResource> about_resource; 756 fake_service_.GetAboutResource( 757 test_util::CreateCopyResultCallback(&error, &about_resource)); 758 base::RunLoop().RunUntilIdle(); 759 760 EXPECT_EQ(HTTP_SUCCESS, error); 761 762 ASSERT_TRUE(about_resource); 763 // Do some sanity check. 764 EXPECT_EQ(fake_service_.GetRootResourceId(), 765 about_resource->root_folder_id()); 766 EXPECT_EQ(1, fake_service_.about_resource_load_count()); 767 } 768 769 TEST_F(FakeDriveServiceTest, GetAboutResource_Offline) { 770 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 771 "gdata/account_metadata.json")); 772 fake_service_.set_offline(true); 773 774 GDataErrorCode error = GDATA_OTHER_ERROR; 775 scoped_ptr<AboutResource> about_resource; 776 fake_service_.GetAboutResource( 777 test_util::CreateCopyResultCallback(&error, &about_resource)); 778 base::RunLoop().RunUntilIdle(); 779 780 EXPECT_EQ(GDATA_NO_CONNECTION, error); 781 EXPECT_FALSE(about_resource); 782 } 783 784 TEST_F(FakeDriveServiceTest, GetAppList) { 785 ASSERT_TRUE(fake_service_.LoadAppListForDriveApi( 786 "drive/applist.json")); 787 788 GDataErrorCode error = GDATA_OTHER_ERROR; 789 scoped_ptr<AppList> app_list; 790 fake_service_.GetAppList( 791 test_util::CreateCopyResultCallback(&error, &app_list)); 792 base::RunLoop().RunUntilIdle(); 793 794 EXPECT_EQ(HTTP_SUCCESS, error); 795 796 ASSERT_TRUE(app_list); 797 EXPECT_EQ(1, fake_service_.app_list_load_count()); 798 } 799 800 TEST_F(FakeDriveServiceTest, GetAppList_Offline) { 801 ASSERT_TRUE(fake_service_.LoadAppListForDriveApi( 802 "drive/applist.json")); 803 fake_service_.set_offline(true); 804 805 GDataErrorCode error = GDATA_OTHER_ERROR; 806 scoped_ptr<AppList> app_list; 807 fake_service_.GetAppList( 808 test_util::CreateCopyResultCallback(&error, &app_list)); 809 base::RunLoop().RunUntilIdle(); 810 811 EXPECT_EQ(GDATA_NO_CONNECTION, error); 812 EXPECT_FALSE(app_list); 813 } 814 815 TEST_F(FakeDriveServiceTest, GetResourceEntry_ExistingFile) { 816 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 817 "gdata/root_feed.json")); 818 819 const std::string kResourceId = "file:2_file_resource_id"; 820 GDataErrorCode error = GDATA_OTHER_ERROR; 821 scoped_ptr<ResourceEntry> resource_entry; 822 fake_service_.GetResourceEntry( 823 kResourceId, 824 test_util::CreateCopyResultCallback(&error, &resource_entry)); 825 base::RunLoop().RunUntilIdle(); 826 827 EXPECT_EQ(HTTP_SUCCESS, error); 828 ASSERT_TRUE(resource_entry); 829 // Do some sanity check. 830 EXPECT_EQ(kResourceId, resource_entry->resource_id()); 831 } 832 833 TEST_F(FakeDriveServiceTest, GetResourceEntry_NonexistingFile) { 834 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 835 "gdata/root_feed.json")); 836 837 const std::string kResourceId = "file:nonexisting_resource_id"; 838 GDataErrorCode error = GDATA_OTHER_ERROR; 839 scoped_ptr<ResourceEntry> resource_entry; 840 fake_service_.GetResourceEntry( 841 kResourceId, 842 test_util::CreateCopyResultCallback(&error, &resource_entry)); 843 base::RunLoop().RunUntilIdle(); 844 845 EXPECT_EQ(HTTP_NOT_FOUND, error); 846 ASSERT_FALSE(resource_entry); 847 } 848 849 TEST_F(FakeDriveServiceTest, GetResourceEntry_Offline) { 850 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 851 "gdata/root_feed.json")); 852 fake_service_.set_offline(true); 853 854 const std::string kResourceId = "file:2_file_resource_id"; 855 GDataErrorCode error = GDATA_OTHER_ERROR; 856 scoped_ptr<ResourceEntry> resource_entry; 857 fake_service_.GetResourceEntry( 858 kResourceId, 859 test_util::CreateCopyResultCallback(&error, &resource_entry)); 860 base::RunLoop().RunUntilIdle(); 861 862 EXPECT_EQ(GDATA_NO_CONNECTION, error); 863 EXPECT_FALSE(resource_entry); 864 } 865 866 TEST_F(FakeDriveServiceTest, GetShareUrl) { 867 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 868 "gdata/root_feed.json")); 869 870 const std::string kResourceId = "file:2_file_resource_id"; 871 GDataErrorCode error = GDATA_OTHER_ERROR; 872 GURL share_url; 873 fake_service_.GetShareUrl( 874 kResourceId, 875 GURL(), // embed origin 876 test_util::CreateCopyResultCallback(&error, &share_url)); 877 base::RunLoop().RunUntilIdle(); 878 879 EXPECT_EQ(HTTP_SUCCESS, error); 880 EXPECT_FALSE(share_url.is_empty()); 881 } 882 883 TEST_F(FakeDriveServiceTest, DeleteResource_ExistingFile) { 884 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 885 "gdata/root_feed.json")); 886 887 // Resource "file:2_file_resource_id" should now exist. 888 ASSERT_TRUE(Exists("file:2_file_resource_id")); 889 890 GDataErrorCode error = GDATA_OTHER_ERROR; 891 fake_service_.DeleteResource("file:2_file_resource_id", 892 std::string(), // etag 893 test_util::CreateCopyResultCallback(&error)); 894 base::RunLoop().RunUntilIdle(); 895 896 EXPECT_EQ(HTTP_NO_CONTENT, error); 897 // Resource "file:2_file_resource_id" should be gone now. 898 EXPECT_FALSE(Exists("file:2_file_resource_id")); 899 900 error = GDATA_OTHER_ERROR; 901 fake_service_.DeleteResource("file:2_file_resource_id", 902 std::string(), // etag 903 test_util::CreateCopyResultCallback(&error)); 904 base::RunLoop().RunUntilIdle(); 905 EXPECT_EQ(HTTP_NOT_FOUND, error); 906 EXPECT_FALSE(Exists("file:2_file_resource_id")); 907 } 908 909 TEST_F(FakeDriveServiceTest, DeleteResource_NonexistingFile) { 910 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 911 "gdata/root_feed.json")); 912 913 GDataErrorCode error = GDATA_OTHER_ERROR; 914 fake_service_.DeleteResource("file:nonexisting_resource_id", 915 std::string(), // etag 916 test_util::CreateCopyResultCallback(&error)); 917 base::RunLoop().RunUntilIdle(); 918 919 EXPECT_EQ(HTTP_NOT_FOUND, error); 920 } 921 922 TEST_F(FakeDriveServiceTest, DeleteResource_ETagMatch) { 923 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 924 "gdata/root_feed.json")); 925 926 // Resource "file:2_file_resource_id" should now exist. 927 scoped_ptr<ResourceEntry> entry = FindEntry("file:2_file_resource_id"); 928 ASSERT_TRUE(entry); 929 ASSERT_FALSE(entry->deleted()); 930 ASSERT_FALSE(entry->etag().empty()); 931 932 GDataErrorCode error = GDATA_OTHER_ERROR; 933 fake_service_.DeleteResource("file:2_file_resource_id", 934 entry->etag() + "_mismatch", 935 test_util::CreateCopyResultCallback(&error)); 936 base::RunLoop().RunUntilIdle(); 937 938 EXPECT_EQ(HTTP_PRECONDITION, error); 939 // Resource "file:2_file_resource_id" should still exist. 940 EXPECT_TRUE(Exists("file:2_file_resource_id")); 941 942 error = GDATA_OTHER_ERROR; 943 fake_service_.DeleteResource("file:2_file_resource_id", 944 entry->etag(), 945 test_util::CreateCopyResultCallback(&error)); 946 base::RunLoop().RunUntilIdle(); 947 EXPECT_EQ(HTTP_NO_CONTENT, error); 948 // Resource "file:2_file_resource_id" should be gone now. 949 EXPECT_FALSE(Exists("file:2_file_resource_id")); 950 } 951 952 TEST_F(FakeDriveServiceTest, DeleteResource_Offline) { 953 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 954 "gdata/root_feed.json")); 955 fake_service_.set_offline(true); 956 957 GDataErrorCode error = GDATA_OTHER_ERROR; 958 fake_service_.DeleteResource("file:2_file_resource_id", 959 std::string(), // etag 960 test_util::CreateCopyResultCallback(&error)); 961 base::RunLoop().RunUntilIdle(); 962 963 EXPECT_EQ(GDATA_NO_CONNECTION, error); 964 } 965 966 TEST_F(FakeDriveServiceTest, TrashResource_ExistingFile) { 967 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 968 "gdata/root_feed.json")); 969 970 // Resource "file:2_file_resource_id" should now exist. 971 ASSERT_TRUE(Exists("file:2_file_resource_id")); 972 973 GDataErrorCode error = GDATA_OTHER_ERROR; 974 fake_service_.TrashResource("file:2_file_resource_id", 975 test_util::CreateCopyResultCallback(&error)); 976 base::RunLoop().RunUntilIdle(); 977 978 EXPECT_EQ(HTTP_SUCCESS, error); 979 // Resource "file:2_file_resource_id" should be gone now. 980 EXPECT_FALSE(Exists("file:2_file_resource_id")); 981 982 error = GDATA_OTHER_ERROR; 983 fake_service_.TrashResource("file:2_file_resource_id", 984 test_util::CreateCopyResultCallback(&error)); 985 base::RunLoop().RunUntilIdle(); 986 EXPECT_EQ(HTTP_NOT_FOUND, error); 987 EXPECT_FALSE(Exists("file:2_file_resource_id")); 988 } 989 990 TEST_F(FakeDriveServiceTest, TrashResource_NonexistingFile) { 991 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 992 "gdata/root_feed.json")); 993 994 GDataErrorCode error = GDATA_OTHER_ERROR; 995 fake_service_.TrashResource("file:nonexisting_resource_id", 996 test_util::CreateCopyResultCallback(&error)); 997 base::RunLoop().RunUntilIdle(); 998 999 EXPECT_EQ(HTTP_NOT_FOUND, error); 1000 } 1001 1002 TEST_F(FakeDriveServiceTest, TrashResource_Offline) { 1003 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1004 "gdata/root_feed.json")); 1005 fake_service_.set_offline(true); 1006 1007 GDataErrorCode error = GDATA_OTHER_ERROR; 1008 fake_service_.TrashResource("file:2_file_resource_id", 1009 test_util::CreateCopyResultCallback(&error)); 1010 base::RunLoop().RunUntilIdle(); 1011 1012 EXPECT_EQ(GDATA_NO_CONNECTION, error); 1013 } 1014 1015 TEST_F(FakeDriveServiceTest, DownloadFile_ExistingFile) { 1016 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1017 "gdata/root_feed.json")); 1018 1019 base::ScopedTempDir temp_dir; 1020 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); 1021 1022 std::vector<test_util::ProgressInfo> download_progress_values; 1023 1024 const base::FilePath kOutputFilePath = 1025 temp_dir.path().AppendASCII("whatever.txt"); 1026 GDataErrorCode error = GDATA_OTHER_ERROR; 1027 base::FilePath output_file_path; 1028 test_util::TestGetContentCallback get_content_callback; 1029 fake_service_.DownloadFile( 1030 kOutputFilePath, 1031 "file:2_file_resource_id", 1032 test_util::CreateCopyResultCallback(&error, &output_file_path), 1033 get_content_callback.callback(), 1034 base::Bind(&test_util::AppendProgressCallbackResult, 1035 &download_progress_values)); 1036 base::RunLoop().RunUntilIdle(); 1037 1038 EXPECT_EQ(HTTP_SUCCESS, error); 1039 EXPECT_EQ(output_file_path, kOutputFilePath); 1040 std::string content; 1041 ASSERT_TRUE(base::ReadFileToString(output_file_path, &content)); 1042 // The content is "x"s of the file size specified in root_feed.json. 1043 EXPECT_EQ("This is some test content.", content); 1044 ASSERT_TRUE(!download_progress_values.empty()); 1045 EXPECT_TRUE(base::STLIsSorted(download_progress_values)); 1046 EXPECT_LE(0, download_progress_values.front().first); 1047 EXPECT_GE(26, download_progress_values.back().first); 1048 EXPECT_EQ(content, get_content_callback.GetConcatenatedData()); 1049 } 1050 1051 TEST_F(FakeDriveServiceTest, DownloadFile_NonexistingFile) { 1052 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1053 "gdata/root_feed.json")); 1054 1055 base::ScopedTempDir temp_dir; 1056 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); 1057 1058 const base::FilePath kOutputFilePath = 1059 temp_dir.path().AppendASCII("whatever.txt"); 1060 GDataErrorCode error = GDATA_OTHER_ERROR; 1061 base::FilePath output_file_path; 1062 fake_service_.DownloadFile( 1063 kOutputFilePath, 1064 "file:non_existent_file_resource_id", 1065 test_util::CreateCopyResultCallback(&error, &output_file_path), 1066 GetContentCallback(), 1067 ProgressCallback()); 1068 base::RunLoop().RunUntilIdle(); 1069 1070 EXPECT_EQ(HTTP_NOT_FOUND, error); 1071 } 1072 1073 TEST_F(FakeDriveServiceTest, DownloadFile_Offline) { 1074 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1075 "gdata/root_feed.json")); 1076 fake_service_.set_offline(true); 1077 1078 base::ScopedTempDir temp_dir; 1079 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); 1080 1081 const base::FilePath kOutputFilePath = 1082 temp_dir.path().AppendASCII("whatever.txt"); 1083 GDataErrorCode error = GDATA_OTHER_ERROR; 1084 base::FilePath output_file_path; 1085 fake_service_.DownloadFile( 1086 kOutputFilePath, 1087 "file:2_file_resource_id", 1088 test_util::CreateCopyResultCallback(&error, &output_file_path), 1089 GetContentCallback(), 1090 ProgressCallback()); 1091 base::RunLoop().RunUntilIdle(); 1092 1093 EXPECT_EQ(GDATA_NO_CONNECTION, error); 1094 } 1095 1096 TEST_F(FakeDriveServiceTest, CopyResource) { 1097 const base::Time::Exploded kModifiedDate = {2012, 7, 0, 19, 15, 59, 13, 123}; 1098 1099 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1100 "gdata/root_feed.json")); 1101 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 1102 "gdata/account_metadata.json")); 1103 1104 int64 old_largest_change_id = GetLargestChangeByAboutResource(); 1105 1106 const std::string kResourceId = "file:2_file_resource_id"; 1107 const std::string kParentResourceId = "folder:2_folder_resource_id"; 1108 GDataErrorCode error = GDATA_OTHER_ERROR; 1109 scoped_ptr<ResourceEntry> resource_entry; 1110 fake_service_.CopyResource( 1111 kResourceId, 1112 kParentResourceId, 1113 "new title", 1114 base::Time::FromUTCExploded(kModifiedDate), 1115 test_util::CreateCopyResultCallback(&error, &resource_entry)); 1116 base::RunLoop().RunUntilIdle(); 1117 1118 EXPECT_EQ(HTTP_SUCCESS, error); 1119 ASSERT_TRUE(resource_entry); 1120 // The copied entry should have the new resource ID and the title. 1121 EXPECT_EQ(kResourceId + "_copied", resource_entry->resource_id()); 1122 EXPECT_EQ("new title", resource_entry->title()); 1123 EXPECT_EQ(base::Time::FromUTCExploded(kModifiedDate), 1124 resource_entry->updated_time()); 1125 EXPECT_TRUE(HasParent(resource_entry->resource_id(), kParentResourceId)); 1126 // Should be incremented as a new hosted document was created. 1127 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); 1128 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); 1129 } 1130 1131 TEST_F(FakeDriveServiceTest, CopyResource_NonExisting) { 1132 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1133 "gdata/root_feed.json")); 1134 1135 const std::string kResourceId = "document:nonexisting_resource_id"; 1136 GDataErrorCode error = GDATA_OTHER_ERROR; 1137 scoped_ptr<ResourceEntry> resource_entry; 1138 fake_service_.CopyResource( 1139 kResourceId, 1140 "folder:1_folder_resource_id", 1141 "new title", 1142 base::Time(), 1143 test_util::CreateCopyResultCallback(&error, &resource_entry)); 1144 base::RunLoop().RunUntilIdle(); 1145 1146 EXPECT_EQ(HTTP_NOT_FOUND, error); 1147 } 1148 1149 TEST_F(FakeDriveServiceTest, CopyResource_EmptyParentResourceId) { 1150 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1151 "gdata/root_feed.json")); 1152 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 1153 "gdata/account_metadata.json")); 1154 1155 int64 old_largest_change_id = GetLargestChangeByAboutResource(); 1156 1157 const std::string kResourceId = "file:2_file_resource_id"; 1158 GDataErrorCode error = GDATA_OTHER_ERROR; 1159 scoped_ptr<ResourceEntry> resource_entry; 1160 fake_service_.CopyResource( 1161 kResourceId, 1162 std::string(), 1163 "new title", 1164 base::Time(), 1165 test_util::CreateCopyResultCallback(&error, &resource_entry)); 1166 base::RunLoop().RunUntilIdle(); 1167 1168 EXPECT_EQ(HTTP_SUCCESS, error); 1169 ASSERT_TRUE(resource_entry); 1170 // The copied entry should have the new resource ID and the title. 1171 EXPECT_EQ(kResourceId + "_copied", resource_entry->resource_id()); 1172 EXPECT_EQ("new title", resource_entry->title()); 1173 EXPECT_TRUE(HasParent(kResourceId, fake_service_.GetRootResourceId())); 1174 // Should be incremented as a new hosted document was created. 1175 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); 1176 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); 1177 } 1178 1179 TEST_F(FakeDriveServiceTest, CopyResource_Offline) { 1180 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1181 "gdata/root_feed.json")); 1182 fake_service_.set_offline(true); 1183 1184 const std::string kResourceId = "file:2_file_resource_id"; 1185 GDataErrorCode error = GDATA_OTHER_ERROR; 1186 scoped_ptr<ResourceEntry> resource_entry; 1187 fake_service_.CopyResource( 1188 kResourceId, 1189 "folder:1_folder_resource_id", 1190 "new title", 1191 base::Time(), 1192 test_util::CreateCopyResultCallback(&error, &resource_entry)); 1193 base::RunLoop().RunUntilIdle(); 1194 1195 EXPECT_EQ(GDATA_NO_CONNECTION, error); 1196 EXPECT_FALSE(resource_entry); 1197 } 1198 1199 TEST_F(FakeDriveServiceTest, UpdateResource) { 1200 const base::Time::Exploded kModifiedDate = {2012, 7, 0, 19, 15, 59, 13, 123}; 1201 const base::Time::Exploded kViewedDate = {2013, 8, 1, 20, 16, 00, 14, 234}; 1202 1203 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1204 "gdata/root_feed.json")); 1205 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 1206 "gdata/account_metadata.json")); 1207 1208 int64 old_largest_change_id = GetLargestChangeByAboutResource(); 1209 1210 const std::string kResourceId = "file:2_file_resource_id"; 1211 const std::string kParentResourceId = "folder:2_folder_resource_id"; 1212 GDataErrorCode error = GDATA_OTHER_ERROR; 1213 scoped_ptr<ResourceEntry> resource_entry; 1214 fake_service_.UpdateResource( 1215 kResourceId, 1216 kParentResourceId, 1217 "new title", 1218 base::Time::FromUTCExploded(kModifiedDate), 1219 base::Time::FromUTCExploded(kViewedDate), 1220 test_util::CreateCopyResultCallback(&error, &resource_entry)); 1221 base::RunLoop().RunUntilIdle(); 1222 1223 EXPECT_EQ(HTTP_SUCCESS, error); 1224 ASSERT_TRUE(resource_entry); 1225 // The copied entry should have the new resource ID and the title. 1226 EXPECT_EQ(kResourceId, resource_entry->resource_id()); 1227 EXPECT_EQ("new title", resource_entry->title()); 1228 EXPECT_EQ(base::Time::FromUTCExploded(kModifiedDate), 1229 resource_entry->updated_time()); 1230 EXPECT_EQ(base::Time::FromUTCExploded(kViewedDate), 1231 resource_entry->last_viewed_time()); 1232 EXPECT_TRUE(HasParent(kResourceId, kParentResourceId)); 1233 // Should be incremented as a new hosted document was created. 1234 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); 1235 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); 1236 } 1237 1238 TEST_F(FakeDriveServiceTest, UpdateResource_NonExisting) { 1239 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1240 "gdata/root_feed.json")); 1241 1242 const std::string kResourceId = "document:nonexisting_resource_id"; 1243 GDataErrorCode error = GDATA_OTHER_ERROR; 1244 scoped_ptr<ResourceEntry> resource_entry; 1245 fake_service_.UpdateResource( 1246 kResourceId, 1247 "folder:1_folder_resource_id", 1248 "new title", 1249 base::Time(), 1250 base::Time(), 1251 test_util::CreateCopyResultCallback(&error, &resource_entry)); 1252 base::RunLoop().RunUntilIdle(); 1253 1254 EXPECT_EQ(HTTP_NOT_FOUND, error); 1255 } 1256 1257 TEST_F(FakeDriveServiceTest, UpdateResource_EmptyParentResourceId) { 1258 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1259 "gdata/root_feed.json")); 1260 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 1261 "gdata/account_metadata.json")); 1262 1263 int64 old_largest_change_id = GetLargestChangeByAboutResource(); 1264 1265 const std::string kResourceId = "file:2_file_resource_id"; 1266 1267 // Just make sure that the resource is under root. 1268 ASSERT_TRUE(HasParent(kResourceId, "fake_root")); 1269 1270 GDataErrorCode error = GDATA_OTHER_ERROR; 1271 scoped_ptr<ResourceEntry> resource_entry; 1272 fake_service_.UpdateResource( 1273 kResourceId, 1274 std::string(), 1275 "new title", 1276 base::Time(), 1277 base::Time(), 1278 test_util::CreateCopyResultCallback(&error, &resource_entry)); 1279 base::RunLoop().RunUntilIdle(); 1280 1281 EXPECT_EQ(HTTP_SUCCESS, error); 1282 ASSERT_TRUE(resource_entry); 1283 // The copied entry should have the new resource ID and the title. 1284 EXPECT_EQ(kResourceId, resource_entry->resource_id()); 1285 EXPECT_EQ("new title", resource_entry->title()); 1286 EXPECT_TRUE(HasParent(kResourceId, "fake_root")); 1287 // Should be incremented as a new hosted document was created. 1288 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); 1289 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); 1290 } 1291 1292 TEST_F(FakeDriveServiceTest, UpdateResource_Offline) { 1293 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1294 "gdata/root_feed.json")); 1295 fake_service_.set_offline(true); 1296 1297 const std::string kResourceId = "file:2_file_resource_id"; 1298 GDataErrorCode error = GDATA_OTHER_ERROR; 1299 scoped_ptr<ResourceEntry> resource_entry; 1300 fake_service_.UpdateResource( 1301 kResourceId, 1302 std::string(), 1303 "new title", 1304 base::Time(), 1305 base::Time(), 1306 test_util::CreateCopyResultCallback(&error, &resource_entry)); 1307 base::RunLoop().RunUntilIdle(); 1308 1309 EXPECT_EQ(GDATA_NO_CONNECTION, error); 1310 EXPECT_FALSE(resource_entry); 1311 } 1312 1313 TEST_F(FakeDriveServiceTest, RenameResource_ExistingFile) { 1314 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1315 "gdata/root_feed.json")); 1316 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 1317 "gdata/account_metadata.json")); 1318 1319 int64 old_largest_change_id = GetLargestChangeByAboutResource(); 1320 1321 const std::string kResourceId = "file:2_file_resource_id"; 1322 1323 GDataErrorCode error = GDATA_OTHER_ERROR; 1324 fake_service_.RenameResource(kResourceId, 1325 "new title", 1326 test_util::CreateCopyResultCallback(&error)); 1327 base::RunLoop().RunUntilIdle(); 1328 1329 EXPECT_EQ(HTTP_SUCCESS, error); 1330 1331 scoped_ptr<ResourceEntry> resource_entry = FindEntry(kResourceId); 1332 ASSERT_TRUE(resource_entry); 1333 EXPECT_EQ("new title", resource_entry->title()); 1334 // Should be incremented as a file was renamed. 1335 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); 1336 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); 1337 } 1338 1339 TEST_F(FakeDriveServiceTest, RenameResource_NonexistingFile) { 1340 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1341 "gdata/root_feed.json")); 1342 1343 const std::string kResourceId = "file:nonexisting_file"; 1344 1345 GDataErrorCode error = GDATA_OTHER_ERROR; 1346 fake_service_.RenameResource(kResourceId, 1347 "new title", 1348 test_util::CreateCopyResultCallback(&error)); 1349 base::RunLoop().RunUntilIdle(); 1350 1351 EXPECT_EQ(HTTP_NOT_FOUND, error); 1352 } 1353 1354 TEST_F(FakeDriveServiceTest, RenameResource_Offline) { 1355 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1356 "gdata/root_feed.json")); 1357 fake_service_.set_offline(true); 1358 1359 const std::string kResourceId = "file:2_file_resource_id"; 1360 1361 GDataErrorCode error = GDATA_OTHER_ERROR; 1362 fake_service_.RenameResource(kResourceId, 1363 "new title", 1364 test_util::CreateCopyResultCallback(&error)); 1365 base::RunLoop().RunUntilIdle(); 1366 1367 EXPECT_EQ(GDATA_NO_CONNECTION, error); 1368 } 1369 1370 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_FileInRootDirectory) { 1371 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1372 "gdata/root_feed.json")); 1373 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 1374 "gdata/account_metadata.json")); 1375 1376 int64 old_largest_change_id = GetLargestChangeByAboutResource(); 1377 1378 const std::string kResourceId = "file:2_file_resource_id"; 1379 const std::string kOldParentResourceId = fake_service_.GetRootResourceId(); 1380 const std::string kNewParentResourceId = "folder:1_folder_resource_id"; 1381 1382 // Here's the original parent link. 1383 EXPECT_TRUE(HasParent(kResourceId, kOldParentResourceId)); 1384 EXPECT_FALSE(HasParent(kResourceId, kNewParentResourceId)); 1385 1386 GDataErrorCode error = GDATA_OTHER_ERROR; 1387 fake_service_.AddResourceToDirectory( 1388 kNewParentResourceId, 1389 kResourceId, 1390 test_util::CreateCopyResultCallback(&error)); 1391 base::RunLoop().RunUntilIdle(); 1392 1393 EXPECT_EQ(HTTP_SUCCESS, error); 1394 1395 // The parent link should now be changed. 1396 EXPECT_TRUE(HasParent(kResourceId, kOldParentResourceId)); 1397 EXPECT_TRUE(HasParent(kResourceId, kNewParentResourceId)); 1398 // Should be incremented as a file was moved. 1399 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); 1400 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); 1401 } 1402 1403 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_FileInNonRootDirectory) { 1404 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1405 "gdata/root_feed.json")); 1406 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 1407 "gdata/account_metadata.json")); 1408 1409 int64 old_largest_change_id = GetLargestChangeByAboutResource(); 1410 1411 const std::string kResourceId = "file:subdirectory_file_1_id"; 1412 const std::string kOldParentResourceId = "folder:1_folder_resource_id"; 1413 const std::string kNewParentResourceId = "folder:2_folder_resource_id"; 1414 1415 // Here's the original parent link. 1416 EXPECT_TRUE(HasParent(kResourceId, kOldParentResourceId)); 1417 EXPECT_FALSE(HasParent(kResourceId, kNewParentResourceId)); 1418 1419 GDataErrorCode error = GDATA_OTHER_ERROR; 1420 fake_service_.AddResourceToDirectory( 1421 kNewParentResourceId, 1422 kResourceId, 1423 test_util::CreateCopyResultCallback(&error)); 1424 base::RunLoop().RunUntilIdle(); 1425 1426 EXPECT_EQ(HTTP_SUCCESS, error); 1427 1428 // The parent link should now be changed. 1429 EXPECT_TRUE(HasParent(kResourceId, kOldParentResourceId)); 1430 EXPECT_TRUE(HasParent(kResourceId, kNewParentResourceId)); 1431 // Should be incremented as a file was moved. 1432 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); 1433 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); 1434 } 1435 1436 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_NonexistingFile) { 1437 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1438 "gdata/root_feed.json")); 1439 1440 const std::string kResourceId = "file:nonexisting_file"; 1441 const std::string kNewParentResourceId = "folder:1_folder_resource_id"; 1442 1443 GDataErrorCode error = GDATA_OTHER_ERROR; 1444 fake_service_.AddResourceToDirectory( 1445 kNewParentResourceId, 1446 kResourceId, 1447 test_util::CreateCopyResultCallback(&error)); 1448 base::RunLoop().RunUntilIdle(); 1449 1450 EXPECT_EQ(HTTP_NOT_FOUND, error); 1451 } 1452 1453 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_OrphanFile) { 1454 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1455 "gdata/root_feed.json")); 1456 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 1457 "gdata/account_metadata.json")); 1458 1459 int64 old_largest_change_id = GetLargestChangeByAboutResource(); 1460 1461 const std::string kResourceId = "file:1_orphanfile_resource_id"; 1462 const std::string kNewParentResourceId = "folder:1_folder_resource_id"; 1463 1464 // The file does not belong to any directory, even to the root. 1465 EXPECT_FALSE(HasParent(kResourceId, kNewParentResourceId)); 1466 EXPECT_FALSE(HasParent(kResourceId, fake_service_.GetRootResourceId())); 1467 1468 GDataErrorCode error = GDATA_OTHER_ERROR; 1469 fake_service_.AddResourceToDirectory( 1470 kNewParentResourceId, 1471 kResourceId, 1472 test_util::CreateCopyResultCallback(&error)); 1473 base::RunLoop().RunUntilIdle(); 1474 1475 EXPECT_EQ(HTTP_SUCCESS, error); 1476 1477 // The parent link should now be changed. 1478 EXPECT_TRUE(HasParent(kResourceId, kNewParentResourceId)); 1479 EXPECT_FALSE(HasParent(kResourceId, fake_service_.GetRootResourceId())); 1480 // Should be incremented as a file was moved. 1481 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); 1482 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); 1483 } 1484 1485 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_Offline) { 1486 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1487 "gdata/root_feed.json")); 1488 fake_service_.set_offline(true); 1489 1490 const std::string kResourceId = "file:2_file_resource_id"; 1491 const std::string kNewParentResourceId = "folder:1_folder_resource_id"; 1492 1493 GDataErrorCode error = GDATA_OTHER_ERROR; 1494 fake_service_.AddResourceToDirectory( 1495 kNewParentResourceId, 1496 kResourceId, 1497 test_util::CreateCopyResultCallback(&error)); 1498 base::RunLoop().RunUntilIdle(); 1499 1500 EXPECT_EQ(GDATA_NO_CONNECTION, error); 1501 } 1502 1503 TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_ExistingFile) { 1504 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1505 "gdata/root_feed.json")); 1506 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 1507 "gdata/account_metadata.json")); 1508 1509 int64 old_largest_change_id = GetLargestChangeByAboutResource(); 1510 1511 const std::string kResourceId = "file:subdirectory_file_1_id"; 1512 const std::string kParentResourceId = "folder:1_folder_resource_id"; 1513 1514 scoped_ptr<ResourceEntry> resource_entry = FindEntry(kResourceId); 1515 ASSERT_TRUE(resource_entry); 1516 // The parent link should exist now. 1517 const google_apis::Link* parent_link = 1518 resource_entry->GetLinkByType(Link::LINK_PARENT); 1519 ASSERT_TRUE(parent_link); 1520 1521 GDataErrorCode error = GDATA_OTHER_ERROR; 1522 fake_service_.RemoveResourceFromDirectory( 1523 kParentResourceId, 1524 kResourceId, 1525 test_util::CreateCopyResultCallback(&error)); 1526 base::RunLoop().RunUntilIdle(); 1527 1528 EXPECT_EQ(HTTP_NO_CONTENT, error); 1529 1530 resource_entry = FindEntry(kResourceId); 1531 ASSERT_TRUE(resource_entry); 1532 // The parent link should be gone now. 1533 parent_link = resource_entry->GetLinkByType(Link::LINK_PARENT); 1534 ASSERT_FALSE(parent_link); 1535 // Should be incremented as a file was moved to the root directory. 1536 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); 1537 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); 1538 } 1539 1540 TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_NonexistingFile) { 1541 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1542 "gdata/root_feed.json")); 1543 1544 const std::string kResourceId = "file:nonexisting_file"; 1545 const std::string kParentResourceId = "folder:1_folder_resource_id"; 1546 1547 GDataErrorCode error = GDATA_OTHER_ERROR; 1548 fake_service_.RemoveResourceFromDirectory( 1549 kParentResourceId, 1550 kResourceId, 1551 test_util::CreateCopyResultCallback(&error)); 1552 base::RunLoop().RunUntilIdle(); 1553 1554 EXPECT_EQ(HTTP_NOT_FOUND, error); 1555 } 1556 1557 TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_OrphanFile) { 1558 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1559 "gdata/root_feed.json")); 1560 1561 const std::string kResourceId = "file:1_orphanfile_resource_id"; 1562 const std::string kParentResourceId = fake_service_.GetRootResourceId(); 1563 1564 GDataErrorCode error = GDATA_OTHER_ERROR; 1565 fake_service_.RemoveResourceFromDirectory( 1566 kParentResourceId, 1567 kResourceId, 1568 test_util::CreateCopyResultCallback(&error)); 1569 base::RunLoop().RunUntilIdle(); 1570 1571 EXPECT_EQ(HTTP_NOT_FOUND, error); 1572 } 1573 1574 TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_Offline) { 1575 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1576 "gdata/root_feed.json")); 1577 fake_service_.set_offline(true); 1578 1579 const std::string kResourceId = "file:subdirectory_file_1_id"; 1580 const std::string kParentResourceId = "folder:1_folder_resource_id"; 1581 1582 GDataErrorCode error = GDATA_OTHER_ERROR; 1583 fake_service_.RemoveResourceFromDirectory( 1584 kParentResourceId, 1585 kResourceId, 1586 test_util::CreateCopyResultCallback(&error)); 1587 base::RunLoop().RunUntilIdle(); 1588 1589 EXPECT_EQ(GDATA_NO_CONNECTION, error); 1590 } 1591 1592 TEST_F(FakeDriveServiceTest, AddNewDirectory_EmptyParent) { 1593 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1594 "gdata/root_feed.json")); 1595 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 1596 "gdata/account_metadata.json")); 1597 1598 int64 old_largest_change_id = GetLargestChangeByAboutResource(); 1599 1600 GDataErrorCode error = GDATA_OTHER_ERROR; 1601 scoped_ptr<ResourceEntry> resource_entry; 1602 fake_service_.AddNewDirectory( 1603 std::string(), 1604 "new directory", 1605 test_util::CreateCopyResultCallback(&error, &resource_entry)); 1606 base::RunLoop().RunUntilIdle(); 1607 1608 EXPECT_EQ(HTTP_CREATED, error); 1609 ASSERT_TRUE(resource_entry); 1610 EXPECT_TRUE(resource_entry->is_folder()); 1611 EXPECT_EQ("resource_id_1", resource_entry->resource_id()); 1612 EXPECT_EQ("new directory", resource_entry->title()); 1613 EXPECT_TRUE(HasParent(resource_entry->resource_id(), 1614 fake_service_.GetRootResourceId())); 1615 // Should be incremented as a new directory was created. 1616 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); 1617 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); 1618 } 1619 1620 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToRootDirectory) { 1621 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1622 "gdata/root_feed.json")); 1623 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 1624 "gdata/account_metadata.json")); 1625 1626 int64 old_largest_change_id = GetLargestChangeByAboutResource(); 1627 1628 GDataErrorCode error = GDATA_OTHER_ERROR; 1629 scoped_ptr<ResourceEntry> resource_entry; 1630 fake_service_.AddNewDirectory( 1631 fake_service_.GetRootResourceId(), 1632 "new directory", 1633 test_util::CreateCopyResultCallback(&error, &resource_entry)); 1634 base::RunLoop().RunUntilIdle(); 1635 1636 EXPECT_EQ(HTTP_CREATED, error); 1637 ASSERT_TRUE(resource_entry); 1638 EXPECT_TRUE(resource_entry->is_folder()); 1639 EXPECT_EQ("resource_id_1", resource_entry->resource_id()); 1640 EXPECT_EQ("new directory", resource_entry->title()); 1641 EXPECT_TRUE(HasParent(resource_entry->resource_id(), 1642 fake_service_.GetRootResourceId())); 1643 // Should be incremented as a new directory was created. 1644 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); 1645 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); 1646 } 1647 1648 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToRootDirectoryOnEmptyFileSystem) { 1649 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1650 "gdata/empty_feed.json")); 1651 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 1652 "gdata/account_metadata.json")); 1653 1654 int64 old_largest_change_id = GetLargestChangeByAboutResource(); 1655 1656 GDataErrorCode error = GDATA_OTHER_ERROR; 1657 scoped_ptr<ResourceEntry> resource_entry; 1658 fake_service_.AddNewDirectory( 1659 fake_service_.GetRootResourceId(), 1660 "new directory", 1661 test_util::CreateCopyResultCallback(&error, &resource_entry)); 1662 base::RunLoop().RunUntilIdle(); 1663 1664 EXPECT_EQ(HTTP_CREATED, error); 1665 ASSERT_TRUE(resource_entry); 1666 EXPECT_TRUE(resource_entry->is_folder()); 1667 EXPECT_EQ("resource_id_1", resource_entry->resource_id()); 1668 EXPECT_EQ("new directory", resource_entry->title()); 1669 EXPECT_TRUE(HasParent(resource_entry->resource_id(), 1670 fake_service_.GetRootResourceId())); 1671 // Should be incremented as a new directory was created. 1672 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); 1673 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); 1674 } 1675 1676 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToNonRootDirectory) { 1677 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1678 "gdata/root_feed.json")); 1679 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 1680 "gdata/account_metadata.json")); 1681 1682 int64 old_largest_change_id = GetLargestChangeByAboutResource(); 1683 1684 const std::string kParentResourceId = "folder:1_folder_resource_id"; 1685 1686 GDataErrorCode error = GDATA_OTHER_ERROR; 1687 scoped_ptr<ResourceEntry> resource_entry; 1688 fake_service_.AddNewDirectory( 1689 kParentResourceId, 1690 "new directory", 1691 test_util::CreateCopyResultCallback(&error, &resource_entry)); 1692 base::RunLoop().RunUntilIdle(); 1693 1694 EXPECT_EQ(HTTP_CREATED, error); 1695 ASSERT_TRUE(resource_entry); 1696 EXPECT_TRUE(resource_entry->is_folder()); 1697 EXPECT_EQ("resource_id_1", resource_entry->resource_id()); 1698 EXPECT_EQ("new directory", resource_entry->title()); 1699 EXPECT_TRUE(HasParent(resource_entry->resource_id(), kParentResourceId)); 1700 // Should be incremented as a new directory was created. 1701 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); 1702 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); 1703 } 1704 1705 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToNonexistingDirectory) { 1706 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1707 "gdata/root_feed.json")); 1708 1709 const std::string kParentResourceId = "folder:nonexisting_resource_id"; 1710 1711 GDataErrorCode error = GDATA_OTHER_ERROR; 1712 scoped_ptr<ResourceEntry> resource_entry; 1713 fake_service_.AddNewDirectory( 1714 kParentResourceId, 1715 "new directory", 1716 test_util::CreateCopyResultCallback(&error, &resource_entry)); 1717 base::RunLoop().RunUntilIdle(); 1718 1719 EXPECT_EQ(HTTP_NOT_FOUND, error); 1720 EXPECT_FALSE(resource_entry); 1721 } 1722 1723 TEST_F(FakeDriveServiceTest, AddNewDirectory_Offline) { 1724 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1725 "gdata/root_feed.json")); 1726 fake_service_.set_offline(true); 1727 1728 GDataErrorCode error = GDATA_OTHER_ERROR; 1729 scoped_ptr<ResourceEntry> resource_entry; 1730 fake_service_.AddNewDirectory( 1731 fake_service_.GetRootResourceId(), 1732 "new directory", 1733 test_util::CreateCopyResultCallback(&error, &resource_entry)); 1734 base::RunLoop().RunUntilIdle(); 1735 1736 EXPECT_EQ(GDATA_NO_CONNECTION, error); 1737 EXPECT_FALSE(resource_entry); 1738 } 1739 1740 TEST_F(FakeDriveServiceTest, InitiateUploadNewFile_Offline) { 1741 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1742 "gdata/root_feed.json")); 1743 fake_service_.set_offline(true); 1744 1745 GDataErrorCode error = GDATA_OTHER_ERROR; 1746 GURL upload_location; 1747 fake_service_.InitiateUploadNewFile( 1748 "test/foo", 1749 13, 1750 "folder:1_folder_resource_id", 1751 "new file.foo", 1752 test_util::CreateCopyResultCallback(&error, &upload_location)); 1753 base::RunLoop().RunUntilIdle(); 1754 1755 EXPECT_EQ(GDATA_NO_CONNECTION, error); 1756 EXPECT_TRUE(upload_location.is_empty()); 1757 } 1758 1759 TEST_F(FakeDriveServiceTest, InitiateUploadNewFile_NotFound) { 1760 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1761 "gdata/root_feed.json")); 1762 1763 GDataErrorCode error = GDATA_OTHER_ERROR; 1764 GURL upload_location; 1765 fake_service_.InitiateUploadNewFile( 1766 "test/foo", 1767 13, 1768 "non_existent", 1769 "new file.foo", 1770 test_util::CreateCopyResultCallback(&error, &upload_location)); 1771 base::RunLoop().RunUntilIdle(); 1772 1773 EXPECT_EQ(HTTP_NOT_FOUND, error); 1774 EXPECT_TRUE(upload_location.is_empty()); 1775 } 1776 1777 TEST_F(FakeDriveServiceTest, InitiateUploadNewFile) { 1778 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1779 "gdata/root_feed.json")); 1780 1781 GDataErrorCode error = GDATA_OTHER_ERROR; 1782 GURL upload_location; 1783 fake_service_.InitiateUploadNewFile( 1784 "test/foo", 1785 13, 1786 "folder:1_folder_resource_id", 1787 "new file.foo", 1788 test_util::CreateCopyResultCallback(&error, &upload_location)); 1789 base::RunLoop().RunUntilIdle(); 1790 1791 EXPECT_EQ(HTTP_SUCCESS, error); 1792 EXPECT_FALSE(upload_location.is_empty()); 1793 EXPECT_NE(GURL("https://1_folder_resumable_create_media_link?mode=newfile"), 1794 upload_location); 1795 } 1796 1797 TEST_F(FakeDriveServiceTest, InitiateUploadExistingFile_Offline) { 1798 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1799 "gdata/root_feed.json")); 1800 fake_service_.set_offline(true); 1801 1802 GDataErrorCode error = GDATA_OTHER_ERROR; 1803 GURL upload_location; 1804 fake_service_.InitiateUploadExistingFile( 1805 "test/foo", 1806 13, 1807 "file:2_file_resource_id", 1808 std::string(), // etag 1809 test_util::CreateCopyResultCallback(&error, &upload_location)); 1810 base::RunLoop().RunUntilIdle(); 1811 1812 EXPECT_EQ(GDATA_NO_CONNECTION, error); 1813 EXPECT_TRUE(upload_location.is_empty()); 1814 } 1815 1816 TEST_F(FakeDriveServiceTest, InitiateUploadExistingFile_NotFound) { 1817 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1818 "gdata/root_feed.json")); 1819 1820 GDataErrorCode error = GDATA_OTHER_ERROR; 1821 GURL upload_location; 1822 fake_service_.InitiateUploadExistingFile( 1823 "test/foo", 1824 13, 1825 "non_existent", 1826 std::string(), // etag 1827 test_util::CreateCopyResultCallback(&error, &upload_location)); 1828 base::RunLoop().RunUntilIdle(); 1829 1830 EXPECT_EQ(HTTP_NOT_FOUND, error); 1831 EXPECT_TRUE(upload_location.is_empty()); 1832 } 1833 1834 TEST_F(FakeDriveServiceTest, InitiateUploadExistingFile_WrongETag) { 1835 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1836 "gdata/root_feed.json")); 1837 1838 GDataErrorCode error = GDATA_OTHER_ERROR; 1839 GURL upload_location; 1840 fake_service_.InitiateUploadExistingFile( 1841 "text/plain", 1842 13, 1843 "file:2_file_resource_id", 1844 "invalid_etag", 1845 test_util::CreateCopyResultCallback(&error, &upload_location)); 1846 base::RunLoop().RunUntilIdle(); 1847 1848 EXPECT_EQ(HTTP_PRECONDITION, error); 1849 EXPECT_TRUE(upload_location.is_empty()); 1850 } 1851 1852 TEST_F(FakeDriveServiceTest, InitiateUpload_ExistingFile) { 1853 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1854 "gdata/root_feed.json")); 1855 1856 GDataErrorCode error = GDATA_OTHER_ERROR; 1857 GURL upload_location; 1858 fake_service_.InitiateUploadExistingFile( 1859 "text/plain", 1860 13, 1861 "file:2_file_resource_id", 1862 "\"HhMOFgxXHit7ImBr\"", 1863 test_util::CreateCopyResultCallback(&error, &upload_location)); 1864 base::RunLoop().RunUntilIdle(); 1865 1866 EXPECT_EQ(HTTP_SUCCESS, error); 1867 EXPECT_TRUE(upload_location.is_valid()); 1868 } 1869 1870 TEST_F(FakeDriveServiceTest, ResumeUpload_Offline) { 1871 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1872 "gdata/root_feed.json")); 1873 1874 GDataErrorCode error = GDATA_OTHER_ERROR; 1875 GURL upload_location; 1876 fake_service_.InitiateUploadNewFile( 1877 "test/foo", 1878 15, 1879 "folder:1_folder_resource_id", 1880 "new file.foo", 1881 test_util::CreateCopyResultCallback(&error, &upload_location)); 1882 base::RunLoop().RunUntilIdle(); 1883 1884 EXPECT_EQ(HTTP_SUCCESS, error); 1885 EXPECT_FALSE(upload_location.is_empty()); 1886 EXPECT_NE(GURL("https://1_folder_resumable_create_media_link"), 1887 upload_location); 1888 1889 fake_service_.set_offline(true); 1890 1891 UploadRangeResponse response; 1892 scoped_ptr<ResourceEntry> entry; 1893 fake_service_.ResumeUpload( 1894 upload_location, 1895 0, 13, 15, "test/foo", 1896 base::FilePath(), 1897 test_util::CreateCopyResultCallback(&response, &entry), 1898 ProgressCallback()); 1899 base::RunLoop().RunUntilIdle(); 1900 1901 EXPECT_EQ(GDATA_NO_CONNECTION, response.code); 1902 EXPECT_FALSE(entry.get()); 1903 } 1904 1905 TEST_F(FakeDriveServiceTest, ResumeUpload_NotFound) { 1906 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1907 "gdata/root_feed.json")); 1908 1909 GDataErrorCode error = GDATA_OTHER_ERROR; 1910 GURL upload_location; 1911 fake_service_.InitiateUploadNewFile( 1912 "test/foo", 1913 15, 1914 "folder:1_folder_resource_id", 1915 "new file.foo", 1916 test_util::CreateCopyResultCallback(&error, &upload_location)); 1917 base::RunLoop().RunUntilIdle(); 1918 1919 ASSERT_EQ(HTTP_SUCCESS, error); 1920 1921 UploadRangeResponse response; 1922 scoped_ptr<ResourceEntry> entry; 1923 fake_service_.ResumeUpload( 1924 GURL("https://foo.com/"), 1925 0, 13, 15, "test/foo", 1926 base::FilePath(), 1927 test_util::CreateCopyResultCallback(&response, &entry), 1928 ProgressCallback()); 1929 base::RunLoop().RunUntilIdle(); 1930 1931 EXPECT_EQ(HTTP_NOT_FOUND, response.code); 1932 EXPECT_FALSE(entry.get()); 1933 } 1934 1935 TEST_F(FakeDriveServiceTest, ResumeUpload_ExistingFile) { 1936 base::ScopedTempDir temp_dir; 1937 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); 1938 base::FilePath local_file_path = 1939 temp_dir.path().Append(FILE_PATH_LITERAL("File 1.txt")); 1940 std::string contents("hogefugapiyo"); 1941 ASSERT_TRUE(test_util::WriteStringToFile(local_file_path, contents)); 1942 1943 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 1944 "gdata/root_feed.json")); 1945 1946 GDataErrorCode error = GDATA_OTHER_ERROR; 1947 GURL upload_location; 1948 fake_service_.InitiateUploadExistingFile( 1949 "text/plain", 1950 contents.size(), 1951 "file:2_file_resource_id", 1952 "\"HhMOFgxXHit7ImBr\"", 1953 test_util::CreateCopyResultCallback(&error, &upload_location)); 1954 base::RunLoop().RunUntilIdle(); 1955 1956 ASSERT_EQ(HTTP_SUCCESS, error); 1957 1958 UploadRangeResponse response; 1959 scoped_ptr<ResourceEntry> entry; 1960 std::vector<test_util::ProgressInfo> upload_progress_values; 1961 fake_service_.ResumeUpload( 1962 upload_location, 1963 0, contents.size() / 2, contents.size(), "text/plain", 1964 local_file_path, 1965 test_util::CreateCopyResultCallback(&response, &entry), 1966 base::Bind(&test_util::AppendProgressCallbackResult, 1967 &upload_progress_values)); 1968 base::RunLoop().RunUntilIdle(); 1969 1970 EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code); 1971 EXPECT_FALSE(entry.get()); 1972 ASSERT_TRUE(!upload_progress_values.empty()); 1973 EXPECT_TRUE(base::STLIsSorted(upload_progress_values)); 1974 EXPECT_LE(0, upload_progress_values.front().first); 1975 EXPECT_GE(static_cast<int64>(contents.size() / 2), 1976 upload_progress_values.back().first); 1977 1978 upload_progress_values.clear(); 1979 fake_service_.ResumeUpload( 1980 upload_location, 1981 contents.size() / 2, contents.size(), contents.size(), "text/plain", 1982 local_file_path, 1983 test_util::CreateCopyResultCallback(&response, &entry), 1984 base::Bind(&test_util::AppendProgressCallbackResult, 1985 &upload_progress_values)); 1986 base::RunLoop().RunUntilIdle(); 1987 1988 EXPECT_EQ(HTTP_SUCCESS, response.code); 1989 EXPECT_TRUE(entry.get()); 1990 EXPECT_EQ(static_cast<int64>(contents.size()), 1991 entry->file_size()); 1992 EXPECT_TRUE(Exists(entry->resource_id())); 1993 ASSERT_TRUE(!upload_progress_values.empty()); 1994 EXPECT_TRUE(base::STLIsSorted(upload_progress_values)); 1995 EXPECT_LE(0, upload_progress_values.front().first); 1996 EXPECT_GE(static_cast<int64>(contents.size() - contents.size() / 2), 1997 upload_progress_values.back().first); 1998 EXPECT_EQ(base::MD5String(contents), entry->file_md5()); 1999 } 2000 2001 TEST_F(FakeDriveServiceTest, ResumeUpload_NewFile) { 2002 base::ScopedTempDir temp_dir; 2003 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); 2004 base::FilePath local_file_path = 2005 temp_dir.path().Append(FILE_PATH_LITERAL("new file.foo")); 2006 std::string contents("hogefugapiyo"); 2007 ASSERT_TRUE(test_util::WriteStringToFile(local_file_path, contents)); 2008 2009 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 2010 "gdata/root_feed.json")); 2011 2012 GDataErrorCode error = GDATA_OTHER_ERROR; 2013 GURL upload_location; 2014 fake_service_.InitiateUploadNewFile( 2015 "test/foo", 2016 contents.size(), 2017 "folder:1_folder_resource_id", 2018 "new file.foo", 2019 test_util::CreateCopyResultCallback(&error, &upload_location)); 2020 base::RunLoop().RunUntilIdle(); 2021 2022 EXPECT_EQ(HTTP_SUCCESS, error); 2023 EXPECT_FALSE(upload_location.is_empty()); 2024 EXPECT_NE(GURL("https://1_folder_resumable_create_media_link"), 2025 upload_location); 2026 2027 UploadRangeResponse response; 2028 scoped_ptr<ResourceEntry> entry; 2029 std::vector<test_util::ProgressInfo> upload_progress_values; 2030 fake_service_.ResumeUpload( 2031 upload_location, 2032 0, contents.size() / 2, contents.size(), "test/foo", 2033 local_file_path, 2034 test_util::CreateCopyResultCallback(&response, &entry), 2035 base::Bind(&test_util::AppendProgressCallbackResult, 2036 &upload_progress_values)); 2037 base::RunLoop().RunUntilIdle(); 2038 2039 EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code); 2040 EXPECT_FALSE(entry.get()); 2041 ASSERT_TRUE(!upload_progress_values.empty()); 2042 EXPECT_TRUE(base::STLIsSorted(upload_progress_values)); 2043 EXPECT_LE(0, upload_progress_values.front().first); 2044 EXPECT_GE(static_cast<int64>(contents.size() / 2), 2045 upload_progress_values.back().first); 2046 2047 upload_progress_values.clear(); 2048 fake_service_.ResumeUpload( 2049 upload_location, 2050 contents.size() / 2, contents.size(), contents.size(), "test/foo", 2051 local_file_path, 2052 test_util::CreateCopyResultCallback(&response, &entry), 2053 base::Bind(&test_util::AppendProgressCallbackResult, 2054 &upload_progress_values)); 2055 base::RunLoop().RunUntilIdle(); 2056 2057 EXPECT_EQ(HTTP_CREATED, response.code); 2058 EXPECT_TRUE(entry.get()); 2059 EXPECT_EQ(static_cast<int64>(contents.size()), entry->file_size()); 2060 EXPECT_TRUE(Exists(entry->resource_id())); 2061 ASSERT_TRUE(!upload_progress_values.empty()); 2062 EXPECT_TRUE(base::STLIsSorted(upload_progress_values)); 2063 EXPECT_LE(0, upload_progress_values.front().first); 2064 EXPECT_GE(static_cast<int64>(contents.size() - contents.size() / 2), 2065 upload_progress_values.back().first); 2066 EXPECT_EQ(base::MD5String(contents), entry->file_md5()); 2067 } 2068 2069 TEST_F(FakeDriveServiceTest, AddNewFile_ToRootDirectory) { 2070 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 2071 "gdata/root_feed.json")); 2072 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 2073 "gdata/account_metadata.json")); 2074 2075 int64 old_largest_change_id = GetLargestChangeByAboutResource(); 2076 2077 const std::string kContentType = "text/plain"; 2078 const std::string kContentData = "This is some test content."; 2079 const std::string kTitle = "new file"; 2080 2081 GDataErrorCode error = GDATA_OTHER_ERROR; 2082 scoped_ptr<ResourceEntry> resource_entry; 2083 fake_service_.AddNewFile( 2084 kContentType, 2085 kContentData, 2086 fake_service_.GetRootResourceId(), 2087 kTitle, 2088 false, // shared_with_me 2089 test_util::CreateCopyResultCallback(&error, &resource_entry)); 2090 base::RunLoop().RunUntilIdle(); 2091 2092 EXPECT_EQ(HTTP_CREATED, error); 2093 ASSERT_TRUE(resource_entry); 2094 EXPECT_TRUE(resource_entry->is_file()); 2095 EXPECT_EQ(kContentType, resource_entry->content_mime_type()); 2096 EXPECT_EQ(static_cast<int64>(kContentData.size()), 2097 resource_entry->file_size()); 2098 EXPECT_EQ("resource_id_1", resource_entry->resource_id()); 2099 EXPECT_EQ(kTitle, resource_entry->title()); 2100 EXPECT_TRUE(HasParent(resource_entry->resource_id(), 2101 fake_service_.GetRootResourceId())); 2102 // Should be incremented as a new directory was created. 2103 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); 2104 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); 2105 EXPECT_EQ(base::MD5String(kContentData), resource_entry->file_md5()); 2106 } 2107 2108 TEST_F(FakeDriveServiceTest, AddNewFile_ToRootDirectoryOnEmptyFileSystem) { 2109 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 2110 "gdata/empty_feed.json")); 2111 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 2112 "gdata/account_metadata.json")); 2113 2114 int64 old_largest_change_id = GetLargestChangeByAboutResource(); 2115 2116 const std::string kContentType = "text/plain"; 2117 const std::string kContentData = "This is some test content."; 2118 const std::string kTitle = "new file"; 2119 2120 GDataErrorCode error = GDATA_OTHER_ERROR; 2121 scoped_ptr<ResourceEntry> resource_entry; 2122 fake_service_.AddNewFile( 2123 kContentType, 2124 kContentData, 2125 fake_service_.GetRootResourceId(), 2126 kTitle, 2127 false, // shared_with_me 2128 test_util::CreateCopyResultCallback(&error, &resource_entry)); 2129 base::RunLoop().RunUntilIdle(); 2130 2131 EXPECT_EQ(HTTP_CREATED, error); 2132 ASSERT_TRUE(resource_entry); 2133 EXPECT_TRUE(resource_entry->is_file()); 2134 EXPECT_EQ(kContentType, resource_entry->content_mime_type()); 2135 EXPECT_EQ(static_cast<int64>(kContentData.size()), 2136 resource_entry->file_size()); 2137 EXPECT_EQ("resource_id_1", resource_entry->resource_id()); 2138 EXPECT_EQ(kTitle, resource_entry->title()); 2139 EXPECT_TRUE(HasParent(resource_entry->resource_id(), 2140 fake_service_.GetRootResourceId())); 2141 // Should be incremented as a new directory was created. 2142 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); 2143 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); 2144 EXPECT_EQ(base::MD5String(kContentData), resource_entry->file_md5()); 2145 } 2146 2147 TEST_F(FakeDriveServiceTest, AddNewFile_ToNonRootDirectory) { 2148 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 2149 "gdata/root_feed.json")); 2150 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 2151 "gdata/account_metadata.json")); 2152 2153 int64 old_largest_change_id = GetLargestChangeByAboutResource(); 2154 2155 const std::string kContentType = "text/plain"; 2156 const std::string kContentData = "This is some test content."; 2157 const std::string kTitle = "new file"; 2158 const std::string kParentResourceId = "folder:1_folder_resource_id"; 2159 2160 GDataErrorCode error = GDATA_OTHER_ERROR; 2161 scoped_ptr<ResourceEntry> resource_entry; 2162 fake_service_.AddNewFile( 2163 kContentType, 2164 kContentData, 2165 kParentResourceId, 2166 kTitle, 2167 false, // shared_with_me 2168 test_util::CreateCopyResultCallback(&error, &resource_entry)); 2169 base::RunLoop().RunUntilIdle(); 2170 2171 EXPECT_EQ(HTTP_CREATED, error); 2172 ASSERT_TRUE(resource_entry); 2173 EXPECT_TRUE(resource_entry->is_file()); 2174 EXPECT_EQ(kContentType, resource_entry->content_mime_type()); 2175 EXPECT_EQ(static_cast<int64>(kContentData.size()), 2176 resource_entry->file_size()); 2177 EXPECT_EQ("resource_id_1", resource_entry->resource_id()); 2178 EXPECT_EQ(kTitle, resource_entry->title()); 2179 EXPECT_TRUE(HasParent(resource_entry->resource_id(), kParentResourceId)); 2180 // Should be incremented as a new directory was created. 2181 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); 2182 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); 2183 EXPECT_EQ(base::MD5String(kContentData), resource_entry->file_md5()); 2184 } 2185 2186 TEST_F(FakeDriveServiceTest, AddNewFile_ToNonexistingDirectory) { 2187 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 2188 "gdata/root_feed.json")); 2189 2190 const std::string kContentType = "text/plain"; 2191 const std::string kContentData = "This is some test content."; 2192 const std::string kTitle = "new file"; 2193 const std::string kParentResourceId = "folder:nonexisting_resource_id"; 2194 2195 GDataErrorCode error = GDATA_OTHER_ERROR; 2196 scoped_ptr<ResourceEntry> resource_entry; 2197 fake_service_.AddNewFile( 2198 kContentType, 2199 kContentData, 2200 kParentResourceId, 2201 kTitle, 2202 false, // shared_with_me 2203 test_util::CreateCopyResultCallback(&error, &resource_entry)); 2204 base::RunLoop().RunUntilIdle(); 2205 2206 EXPECT_EQ(HTTP_NOT_FOUND, error); 2207 EXPECT_FALSE(resource_entry); 2208 } 2209 2210 TEST_F(FakeDriveServiceTest, AddNewFile_Offline) { 2211 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 2212 "gdata/root_feed.json")); 2213 fake_service_.set_offline(true); 2214 2215 const std::string kContentType = "text/plain"; 2216 const std::string kContentData = "This is some test content."; 2217 const std::string kTitle = "new file"; 2218 2219 GDataErrorCode error = GDATA_OTHER_ERROR; 2220 scoped_ptr<ResourceEntry> resource_entry; 2221 fake_service_.AddNewFile( 2222 kContentType, 2223 kContentData, 2224 fake_service_.GetRootResourceId(), 2225 kTitle, 2226 false, // shared_with_me 2227 test_util::CreateCopyResultCallback(&error, &resource_entry)); 2228 base::RunLoop().RunUntilIdle(); 2229 2230 EXPECT_EQ(GDATA_NO_CONNECTION, error); 2231 EXPECT_FALSE(resource_entry); 2232 } 2233 2234 TEST_F(FakeDriveServiceTest, AddNewFile_SharedWithMeLabel) { 2235 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 2236 "gdata/root_feed.json")); 2237 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( 2238 "gdata/account_metadata.json")); 2239 2240 const std::string kContentType = "text/plain"; 2241 const std::string kContentData = "This is some test content."; 2242 const std::string kTitle = "new file"; 2243 2244 int64 old_largest_change_id = GetLargestChangeByAboutResource(); 2245 2246 GDataErrorCode error = GDATA_OTHER_ERROR; 2247 scoped_ptr<ResourceEntry> resource_entry; 2248 fake_service_.AddNewFile( 2249 kContentType, 2250 kContentData, 2251 fake_service_.GetRootResourceId(), 2252 kTitle, 2253 true, // shared_with_me 2254 test_util::CreateCopyResultCallback(&error, &resource_entry)); 2255 base::RunLoop().RunUntilIdle(); 2256 2257 EXPECT_EQ(HTTP_CREATED, error); 2258 ASSERT_TRUE(resource_entry); 2259 EXPECT_TRUE(resource_entry->is_file()); 2260 EXPECT_EQ(kContentType, resource_entry->content_mime_type()); 2261 EXPECT_EQ(static_cast<int64>(kContentData.size()), 2262 resource_entry->file_size()); 2263 EXPECT_EQ("resource_id_1", resource_entry->resource_id()); 2264 EXPECT_EQ(kTitle, resource_entry->title()); 2265 EXPECT_TRUE(HasParent(resource_entry->resource_id(), 2266 fake_service_.GetRootResourceId())); 2267 ASSERT_EQ(1U, resource_entry->labels().size()); 2268 EXPECT_EQ("shared-with-me", resource_entry->labels()[0]); 2269 // Should be incremented as a new directory was created. 2270 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); 2271 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); 2272 EXPECT_EQ(base::MD5String(kContentData), resource_entry->file_md5()); 2273 } 2274 2275 TEST_F(FakeDriveServiceTest, SetLastModifiedTime_ExistingFile) { 2276 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 2277 "gdata/root_feed.json")); 2278 2279 const std::string kResourceId = "file:2_file_resource_id"; 2280 base::Time time; 2281 ASSERT_TRUE(base::Time::FromString("1 April 2013 12:34:56", &time)); 2282 2283 GDataErrorCode error = GDATA_OTHER_ERROR; 2284 scoped_ptr<ResourceEntry> resource_entry; 2285 fake_service_.SetLastModifiedTime( 2286 kResourceId, 2287 time, 2288 test_util::CreateCopyResultCallback(&error, &resource_entry)); 2289 base::RunLoop().RunUntilIdle(); 2290 2291 EXPECT_EQ(HTTP_SUCCESS, error); 2292 ASSERT_TRUE(resource_entry); 2293 EXPECT_EQ(time, resource_entry->updated_time()); 2294 } 2295 2296 TEST_F(FakeDriveServiceTest, SetLastModifiedTime_NonexistingFile) { 2297 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 2298 "gdata/root_feed.json")); 2299 2300 const std::string kResourceId = "file:nonexisting_resource_id"; 2301 base::Time time; 2302 ASSERT_TRUE(base::Time::FromString("1 April 2013 12:34:56", &time)); 2303 2304 GDataErrorCode error = GDATA_OTHER_ERROR; 2305 scoped_ptr<ResourceEntry> resource_entry; 2306 fake_service_.SetLastModifiedTime( 2307 kResourceId, 2308 time, 2309 test_util::CreateCopyResultCallback(&error, &resource_entry)); 2310 base::RunLoop().RunUntilIdle(); 2311 2312 EXPECT_EQ(HTTP_NOT_FOUND, error); 2313 EXPECT_FALSE(resource_entry); 2314 } 2315 2316 TEST_F(FakeDriveServiceTest, SetLastModifiedTime_Offline) { 2317 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( 2318 "gdata/root_feed.json")); 2319 fake_service_.set_offline(true); 2320 2321 const std::string kResourceId = "file:2_file_resource_id"; 2322 base::Time time; 2323 ASSERT_TRUE(base::Time::FromString("1 April 2013 12:34:56", &time)); 2324 2325 GDataErrorCode error = GDATA_OTHER_ERROR; 2326 scoped_ptr<ResourceEntry> resource_entry; 2327 fake_service_.SetLastModifiedTime( 2328 kResourceId, 2329 time, 2330 test_util::CreateCopyResultCallback(&error, &resource_entry)); 2331 base::RunLoop().RunUntilIdle(); 2332 2333 EXPECT_EQ(GDATA_NO_CONNECTION, error); 2334 EXPECT_FALSE(resource_entry); 2335 } 2336 2337 } // namespace 2338 2339 } // namespace drive 2340
