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