chrome/browser/drive/fake_drive_service_unittest.cc

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