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