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