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