drive_backend_sync_unittest.cc revision 5c02ac1a9c1b504631c0a3d2b6e737b5d738bae1 
1// Copyright 2014 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 <algorithm>
6#include <stack>
7
8#include "base/file_util.h"
9#include "base/message_loop/message_loop.h"
10#include "base/run_loop.h"
11#include "chrome/browser/drive/drive_uploader.h"
12#include "chrome/browser/drive/fake_drive_service.h"
13#include "chrome/browser/drive/test_util.h"
14#include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
15#include "chrome/browser/sync_file_system/drive_backend/fake_drive_service_helper.h"
16#include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
17#include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
18#include "chrome/browser/sync_file_system/drive_backend/sync_engine.h"
19#include "chrome/browser/sync_file_system/local/canned_syncable_file_system.h"
20#include "chrome/browser/sync_file_system/local/local_file_sync_context.h"
21#include "chrome/browser/sync_file_system/local/local_file_sync_service.h"
22#include "chrome/browser/sync_file_system/local/sync_file_system_backend.h"
23#include "chrome/browser/sync_file_system/sync_file_system_test_util.h"
24#include "chrome/browser/sync_file_system/syncable_file_system_util.h"
25#include "chrome/test/base/testing_profile.h"
26#include "content/public/test/test_browser_thread.h"
27#include "content/public/test/test_browser_thread_bundle.h"
28#include "extensions/common/extension.h"
29#include "google_apis/drive/drive_api_parser.h"
30#include "testing/gtest/include/gtest/gtest.h"
31#include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
32#include "third_party/leveldatabase/src/include/leveldb/env.h"
33#include "webkit/browser/fileapi/file_system_context.h"
34
35#define FPL(a) FILE_PATH_LITERAL(a)
36
37namespace sync_file_system {
38namespace drive_backend {
39
40typedef fileapi::FileSystemOperation::FileEntryList FileEntryList;
41
42class DriveBackendSyncTest : public testing::Test,
43                             public LocalFileSyncService::Observer,
44                             public RemoteFileSyncService::Observer {
45 public:
46  DriveBackendSyncTest()
47      : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
48        pending_remote_changes_(0),
49        pending_local_changes_(0) {}
50  virtual ~DriveBackendSyncTest() {}
51
52  virtual void SetUp() OVERRIDE {
53    ASSERT_TRUE(base_dir_.CreateUniqueTempDir());
54    in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
55
56    io_task_runner_ = content::BrowserThread::GetMessageLoopProxyForThread(
57        content::BrowserThread::IO);
58    file_task_runner_ = content::BrowserThread::GetMessageLoopProxyForThread(
59        content::BrowserThread::FILE);
60
61    RegisterSyncableFileSystem();
62    local_sync_service_ = LocalFileSyncService::CreateForTesting(
63        &profile_, in_memory_env_.get());
64    local_sync_service_->AddChangeObserver(this);
65
66    scoped_ptr<drive::FakeDriveService> drive_service(
67        new drive::FakeDriveService());
68    drive_service->Initialize("test@example.com");
69    ASSERT_TRUE(drive::test_util::SetUpTestEntries(drive_service.get()));
70
71    scoped_ptr<drive::DriveUploaderInterface> uploader(
72        new drive::DriveUploader(drive_service.get(),
73                                 file_task_runner_.get()));
74
75    fake_drive_service_helper_.reset(new FakeDriveServiceHelper(
76        drive_service.get(), uploader.get(),
77        kSyncRootFolderTitle));
78
79    remote_sync_service_.reset(new SyncEngine(
80        drive_service.PassAs<drive::DriveServiceInterface>(),
81        uploader.Pass(),
82        file_task_runner_.get(),
83        NULL, NULL, NULL));
84    remote_sync_service_->AddServiceObserver(this);
85    remote_sync_service_->Initialize(base_dir_.path(),
86                                     base::MessageLoopProxy::current(),
87                                     in_memory_env_.get());
88    remote_sync_service_->SetSyncEnabled(true);
89
90    local_sync_service_->SetLocalChangeProcessor(remote_sync_service_.get());
91    remote_sync_service_->SetRemoteChangeProcessor(local_sync_service_.get());
92  }
93
94  virtual void TearDown() OVERRIDE {
95    typedef std::map<std::string, CannedSyncableFileSystem*>::iterator iterator;
96    for (iterator itr = file_systems_.begin();
97         itr != file_systems_.end(); ++itr) {
98      itr->second->TearDown();
99      delete itr->second;
100    }
101    file_systems_.clear();
102
103    fake_drive_service_helper_.reset();
104    remote_sync_service_.reset();
105
106    base::RunLoop().RunUntilIdle();
107    RevokeSyncableFileSystem();
108  }
109
110  virtual void OnRemoteChangeQueueUpdated(int64 pending_changes_hint) OVERRIDE {
111    pending_remote_changes_ = pending_changes_hint;
112  }
113
114  virtual void OnLocalChangeAvailable(int64 pending_changes_hint) OVERRIDE {
115    pending_local_changes_ = pending_changes_hint;
116  }
117
118 protected:
119  fileapi::FileSystemURL CreateURL(const std::string& app_id,
120                                   const base::FilePath::StringType& path) {
121    return CreateURL(app_id, base::FilePath(path));
122  }
123
124  fileapi::FileSystemURL CreateURL(const std::string& app_id,
125                                   const base::FilePath& path) {
126    GURL origin = extensions::Extension::GetBaseURLFromExtensionId(app_id);
127    return CreateSyncableFileSystemURL(origin, path);
128  }
129
130  bool GetAppRootFolderID(const std::string& app_id,
131                          std::string* folder_id) {
132    FileTracker tracker;
133    if (!metadata_database()->FindAppRootTracker(app_id, &tracker))
134      return false;
135    *folder_id = tracker.file_id();
136    return true;
137  }
138
139  std::string GetFileIDByPath(const std::string& app_id,
140                              const base::FilePath::StringType& path) {
141    return GetFileIDByPath(app_id, base::FilePath(path));
142  }
143
144  std::string GetFileIDByPath(const std::string& app_id,
145                              const base::FilePath& path) {
146    FileTracker tracker;
147    base::FilePath result_path;
148    base::FilePath normalized_path = path.NormalizePathSeparators();
149    EXPECT_TRUE(metadata_database()->FindNearestActiveAncestor(
150        app_id, normalized_path, &tracker, &result_path));
151    EXPECT_EQ(normalized_path, result_path);
152    return tracker.file_id();
153  }
154
155  SyncStatusCode RegisterApp(const std::string& app_id) {
156    GURL origin = extensions::Extension::GetBaseURLFromExtensionId(app_id);
157    if (!ContainsKey(file_systems_, app_id)) {
158      CannedSyncableFileSystem* file_system = new CannedSyncableFileSystem(
159          origin, in_memory_env_.get(),
160          io_task_runner_.get(), file_task_runner_.get());
161      file_system->SetUp(CannedSyncableFileSystem::QUOTA_DISABLED);
162
163      SyncStatusCode status = SYNC_STATUS_UNKNOWN;
164      local_sync_service_->MaybeInitializeFileSystemContext(
165          origin, file_system->file_system_context(),
166          CreateResultReceiver(&status));
167      base::RunLoop().RunUntilIdle();
168      EXPECT_EQ(SYNC_STATUS_OK, status);
169
170      file_system->backend()->sync_context()->
171          set_mock_notify_changes_duration_in_sec(0);
172
173      EXPECT_EQ(base::File::FILE_OK, file_system->OpenFileSystem());
174      file_systems_[app_id] = file_system;
175    }
176
177    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
178    remote_sync_service_->RegisterOrigin(origin, CreateResultReceiver(&status));
179    base::RunLoop().RunUntilIdle();
180    return status;
181  }
182
183  void AddLocalFolder(const std::string& app_id,
184                      const base::FilePath::StringType& path) {
185    ASSERT_TRUE(ContainsKey(file_systems_, app_id));
186    EXPECT_EQ(base::File::FILE_OK,
187              file_systems_[app_id]->CreateDirectory(
188                  CreateURL(app_id, path)));
189  }
190
191  void AddOrUpdateLocalFile(const std::string& app_id,
192                            const base::FilePath::StringType& path,
193                            const std::string& content) {
194    fileapi::FileSystemURL url(CreateURL(app_id, path));
195    ASSERT_TRUE(ContainsKey(file_systems_, app_id));
196    EXPECT_EQ(base::File::FILE_OK, file_systems_[app_id]->CreateFile(url));
197    int64 bytes_written = file_systems_[app_id]->WriteString(url, content);
198    EXPECT_EQ(static_cast<int64>(content.size()), bytes_written);
199    base::RunLoop().RunUntilIdle();
200  }
201
202  void UpdateLocalFile(const std::string& app_id,
203                       const base::FilePath::StringType& path,
204                       const std::string& content) {
205    ASSERT_TRUE(ContainsKey(file_systems_, app_id));
206    int64 bytes_written = file_systems_[app_id]->WriteString(
207        CreateURL(app_id, path), content);
208    EXPECT_EQ(static_cast<int64>(content.size()), bytes_written);
209    base::RunLoop().RunUntilIdle();
210  }
211
212  void RemoveLocal(const std::string& app_id,
213                   const base::FilePath::StringType& path) {
214    ASSERT_TRUE(ContainsKey(file_systems_, app_id));
215    EXPECT_EQ(base::File::FILE_OK,
216              file_systems_[app_id]->Remove(
217                  CreateURL(app_id, path),
218                  true /* recursive */));
219    base::RunLoop().RunUntilIdle();
220  }
221
222  SyncStatusCode ProcessLocalChange() {
223    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
224    fileapi::FileSystemURL url;
225    local_sync_service_->ProcessLocalChange(
226        CreateResultReceiver(&status, &url));
227    base::RunLoop().RunUntilIdle();
228    return status;
229  }
230
231  SyncStatusCode ProcessRemoteChange() {
232    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
233    fileapi::FileSystemURL url;
234    remote_sync_service_->ProcessRemoteChange(
235        CreateResultReceiver(&status, &url));
236    base::RunLoop().RunUntilIdle();
237    return status;
238  }
239
240  int64 GetLargestChangeID() {
241    scoped_ptr<google_apis::AboutResource> about_resource;
242    EXPECT_EQ(google_apis::HTTP_SUCCESS,
243              fake_drive_service_helper()->GetAboutResource(&about_resource));
244    if (!about_resource)
245      return 0;
246    return about_resource->largest_change_id();
247  }
248
249  void FetchRemoteChanges() {
250    remote_sync_service_->OnNotificationReceived();
251    base::RunLoop().RunUntilIdle();
252  }
253
254  SyncStatusCode ProcessChangesUntilDone() {
255    SyncStatusCode local_sync_status;
256    SyncStatusCode remote_sync_status;
257    while (true) {
258      local_sync_status = ProcessLocalChange();
259      if (local_sync_status != SYNC_STATUS_OK &&
260          local_sync_status != SYNC_STATUS_NO_CHANGE_TO_SYNC &&
261          local_sync_status != SYNC_STATUS_FILE_BUSY)
262        return local_sync_status;
263
264      remote_sync_status = ProcessRemoteChange();
265      if (remote_sync_status != SYNC_STATUS_OK &&
266          remote_sync_status != SYNC_STATUS_NO_CHANGE_TO_SYNC &&
267          remote_sync_status != SYNC_STATUS_FILE_BUSY)
268        return remote_sync_status;
269
270      if (local_sync_status == SYNC_STATUS_NO_CHANGE_TO_SYNC &&
271          remote_sync_status == SYNC_STATUS_NO_CHANGE_TO_SYNC) {
272        remote_sync_service_->PromoteDemotedChanges();
273        local_sync_service_->PromoteDemotedChanges();
274
275        if (pending_remote_changes_ || pending_local_changes_)
276          continue;
277
278        int64 largest_fetched_change_id =
279            metadata_database()->GetLargestFetchedChangeID();
280        if (largest_fetched_change_id != GetLargestChangeID()) {
281          FetchRemoteChanges();
282          continue;
283        }
284        break;
285      }
286    }
287    return SYNC_STATUS_OK;
288  }
289
290  // Verifies local and remote files/folders are consistent.
291  // This function checks:
292  //  - Each registered origin has corresponding remote folder.
293  //  - Each local file/folder has corresponding remote one.
294  //  - Each remote file/folder has corresponding local one.
295  // TODO(tzik): Handle conflict case. i.e. allow remote file has different
296  // file content if the corresponding local file conflicts to it.
297  void VerifyConsistency() {
298    std::string sync_root_folder_id;
299    google_apis::GDataErrorCode error =
300        fake_drive_service_helper_->GetSyncRootFolderID(&sync_root_folder_id);
301    if (sync_root_folder_id.empty()) {
302      EXPECT_EQ(google_apis::HTTP_NOT_FOUND, error);
303      EXPECT_TRUE(file_systems_.empty());
304      return;
305    }
306    EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
307
308    ScopedVector<google_apis::ResourceEntry> remote_entries;
309    EXPECT_EQ(google_apis::HTTP_SUCCESS,
310              fake_drive_service_helper_->ListFilesInFolder(
311                  sync_root_folder_id, &remote_entries));
312    std::map<std::string, const google_apis::ResourceEntry*> app_root_by_title;
313    for (ScopedVector<google_apis::ResourceEntry>::iterator itr =
314             remote_entries.begin();
315         itr != remote_entries.end();
316         ++itr) {
317      const google_apis::ResourceEntry& remote_entry = **itr;
318      EXPECT_FALSE(ContainsKey(app_root_by_title, remote_entry.title()));
319      app_root_by_title[remote_entry.title()] = *itr;
320    }
321
322    for (std::map<std::string, CannedSyncableFileSystem*>::const_iterator itr =
323             file_systems_.begin();
324         itr != file_systems_.end(); ++itr) {
325      const std::string& app_id = itr->first;
326      SCOPED_TRACE(testing::Message() << "Verifying app: " << app_id);
327      CannedSyncableFileSystem* file_system = itr->second;
328      ASSERT_TRUE(ContainsKey(app_root_by_title, app_id));
329      VerifyConsistencyForFolder(
330          app_id, base::FilePath(),
331          app_root_by_title[app_id]->resource_id(),
332          file_system);
333    }
334  }
335
336  void VerifyConsistencyForFolder(const std::string& app_id,
337                                  const base::FilePath& path,
338                                  const std::string& folder_id,
339                                  CannedSyncableFileSystem* file_system) {
340    SCOPED_TRACE(testing::Message() << "Verifying folder: " << path.value());
341
342    ScopedVector<google_apis::ResourceEntry> remote_entries;
343    EXPECT_EQ(google_apis::HTTP_SUCCESS,
344              fake_drive_service_helper_->ListFilesInFolder(
345                  folder_id, &remote_entries));
346    std::map<std::string, const google_apis::ResourceEntry*>
347        remote_entry_by_title;
348    for (size_t i = 0; i < remote_entries.size(); ++i) {
349      google_apis::ResourceEntry* remote_entry = remote_entries[i];
350      EXPECT_FALSE(ContainsKey(remote_entry_by_title, remote_entry->title()))
351          << "title: " << remote_entry->title();
352      remote_entry_by_title[remote_entry->title()] = remote_entry;
353    }
354
355    fileapi::FileSystemURL url(CreateURL(app_id, path));
356    FileEntryList local_entries;
357    EXPECT_EQ(base::File::FILE_OK,
358              file_system->ReadDirectory(url, &local_entries));
359    for (FileEntryList::iterator itr = local_entries.begin();
360         itr != local_entries.end();
361         ++itr) {
362      const fileapi::DirectoryEntry& local_entry = *itr;
363      fileapi::FileSystemURL entry_url(
364          CreateURL(app_id, path.Append(local_entry.name)));
365      std::string title =
366          fileapi::VirtualPath::BaseName(entry_url.path()).AsUTF8Unsafe();
367      SCOPED_TRACE(testing::Message() << "Verifying entry: " << title);
368
369      ASSERT_TRUE(ContainsKey(remote_entry_by_title, title));
370      const google_apis::ResourceEntry& remote_entry =
371          *remote_entry_by_title[title];
372      if (local_entry.is_directory) {
373        ASSERT_TRUE(remote_entry.is_folder());
374        VerifyConsistencyForFolder(app_id, entry_url.path(),
375                                   remote_entry.resource_id(),
376                                   file_system);
377      } else {
378        ASSERT_TRUE(remote_entry.is_file());
379        VerifyConsistencyForFile(app_id, entry_url.path(),
380                                 remote_entry.resource_id(),
381                                 file_system);
382      }
383      remote_entry_by_title.erase(title);
384    }
385
386    EXPECT_TRUE(remote_entry_by_title.empty());
387  }
388
389  void VerifyConsistencyForFile(const std::string& app_id,
390                                const base::FilePath& path,
391                                const std::string& file_id,
392                                CannedSyncableFileSystem* file_system) {
393    fileapi::FileSystemURL url(CreateURL(app_id, path));
394    std::string file_content;
395    EXPECT_EQ(google_apis::HTTP_SUCCESS,
396              fake_drive_service_helper_->ReadFile(file_id, &file_content));
397    EXPECT_EQ(base::File::FILE_OK,
398              file_system->VerifyFile(url, file_content));
399  }
400
401  size_t CountApp() {
402    return file_systems_.size();
403  }
404
405  size_t CountLocalFile(const std::string& app_id) {
406    if (!ContainsKey(file_systems_, app_id))
407      return 0;
408
409    CannedSyncableFileSystem* file_system = file_systems_[app_id];
410    std::stack<base::FilePath> folders;
411    folders.push(base::FilePath());  // root folder
412
413    size_t result = 1;
414    while (!folders.empty()) {
415      fileapi::FileSystemURL url(CreateURL(app_id, folders.top()));
416      folders.pop();
417
418      FileEntryList entries;
419      EXPECT_EQ(base::File::FILE_OK,
420                file_system->ReadDirectory(url, &entries));
421      for (FileEntryList::iterator itr = entries.begin();
422           itr != entries.end(); ++itr) {
423        ++result;
424        if (itr->is_directory)
425          folders.push(url.path().Append(itr->name));
426      }
427    }
428
429    return result;
430  }
431
432  void VerifyLocalFile(const std::string& app_id,
433                       const base::FilePath::StringType& path,
434                       const std::string& content) {
435    SCOPED_TRACE(testing::Message() << "Verifying local file: "
436                                    << "app_id = " << app_id
437                                    << ", path = " << path);
438    ASSERT_TRUE(ContainsKey(file_systems_, app_id));
439    EXPECT_EQ(base::File::FILE_OK,
440              file_systems_[app_id]->VerifyFile(
441                  CreateURL(app_id, path), content));
442  }
443
444  void VerifyLocalFolder(const std::string& app_id,
445                         const base::FilePath::StringType& path) {
446    SCOPED_TRACE(testing::Message() << "Verifying local file: "
447                                    << "app_id = " << app_id
448                                    << ", path = " << path);
449    ASSERT_TRUE(ContainsKey(file_systems_, app_id));
450    EXPECT_EQ(base::File::FILE_OK,
451              file_systems_[app_id]->DirectoryExists(CreateURL(app_id, path)));
452  }
453
454  size_t CountMetadata() {
455    return metadata_database()->CountFileMetadata();
456  }
457
458  size_t CountTracker() {
459    return metadata_database()->CountFileTracker();
460  }
461
462  drive::FakeDriveService* fake_drive_service() {
463    return static_cast<drive::FakeDriveService*>(
464        remote_sync_service_->GetDriveService());
465  }
466
467  FakeDriveServiceHelper* fake_drive_service_helper() {
468    return fake_drive_service_helper_.get();
469  }
470
471  MetadataDatabase* metadata_database() {
472    return remote_sync_service_->GetMetadataDatabase();
473  }
474
475 private:
476  content::TestBrowserThreadBundle thread_bundle_;
477  ScopedEnableSyncFSV2 enable_syncfs_v2_;
478
479  base::ScopedTempDir base_dir_;
480  scoped_ptr<leveldb::Env> in_memory_env_;
481  TestingProfile profile_;
482
483  scoped_ptr<SyncEngine> remote_sync_service_;
484  scoped_ptr<LocalFileSyncService> local_sync_service_;
485
486  int64 pending_remote_changes_;
487  int64 pending_local_changes_;
488
489  scoped_ptr<FakeDriveServiceHelper> fake_drive_service_helper_;
490  std::map<std::string, CannedSyncableFileSystem*> file_systems_;
491
492
493  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
494  scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
495
496  DISALLOW_COPY_AND_ASSIGN(DriveBackendSyncTest);
497};
498
499TEST_F(DriveBackendSyncTest, LocalToRemoteBasicTest) {
500  std::string app_id = "example";
501
502  RegisterApp(app_id);
503  AddOrUpdateLocalFile(app_id, FPL("file"), "abcde");
504
505  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
506  VerifyConsistency();
507
508  EXPECT_EQ(1u, CountApp());
509  EXPECT_EQ(2u, CountLocalFile(app_id));
510  VerifyLocalFile(app_id, FPL("file"), "abcde");
511
512  EXPECT_EQ(3u, CountMetadata());
513  EXPECT_EQ(3u, CountTracker());
514}
515
516TEST_F(DriveBackendSyncTest, RemoteToLocalBasicTest) {
517  std::string app_id = "example";
518  RegisterApp(app_id);
519
520  std::string app_root_folder_id;
521  EXPECT_TRUE(GetAppRootFolderID(app_id, &app_root_folder_id));
522
523  std::string file_id;
524  EXPECT_EQ(google_apis::HTTP_SUCCESS,
525            fake_drive_service_helper()->AddFile(
526                app_root_folder_id, "file", "abcde", &file_id));
527
528  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
529  VerifyConsistency();
530
531  EXPECT_EQ(1u, CountApp());
532  EXPECT_EQ(2u, CountLocalFile(app_id));
533  VerifyLocalFile(app_id, FPL("file"), "abcde");
534
535  EXPECT_EQ(3u, CountMetadata());
536  EXPECT_EQ(3u, CountTracker());
537}
538
539TEST_F(DriveBackendSyncTest, LocalFileUpdateTest) {
540  std::string app_id = "example";
541  const base::FilePath::StringType kPath(FPL("file"));
542
543  RegisterApp(app_id);
544  AddOrUpdateLocalFile(app_id, kPath, "abcde");
545
546  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
547  VerifyConsistency();
548
549  UpdateLocalFile(app_id, kPath, "1234567890");
550
551  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
552  VerifyConsistency();
553
554  EXPECT_EQ(1u, CountApp());
555  EXPECT_EQ(2u, CountLocalFile(app_id));
556  VerifyLocalFile(app_id, FPL("file"), "1234567890");
557
558  EXPECT_EQ(3u, CountMetadata());
559  EXPECT_EQ(3u, CountTracker());
560}
561
562TEST_F(DriveBackendSyncTest, RemoteFileUpdateTest) {
563  std::string app_id = "example";
564
565  RegisterApp(app_id);
566  std::string remote_file_id;
567  std::string app_root_folder_id;
568  EXPECT_TRUE(GetAppRootFolderID(app_id, &app_root_folder_id));
569  EXPECT_EQ(google_apis::HTTP_SUCCESS,
570            fake_drive_service_helper()->AddFile(
571                app_root_folder_id, "file", "abcde", &remote_file_id));
572
573  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
574  VerifyConsistency();
575
576  EXPECT_EQ(google_apis::HTTP_SUCCESS,
577            fake_drive_service_helper()->UpdateFile(
578                remote_file_id, "1234567890"));
579
580  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
581  VerifyConsistency();
582
583  EXPECT_EQ(1u, CountApp());
584  EXPECT_EQ(2u, CountLocalFile(app_id));
585  VerifyLocalFile(app_id, FPL("file"), "1234567890");
586
587  EXPECT_EQ(3u, CountMetadata());
588  EXPECT_EQ(3u, CountTracker());
589}
590
591TEST_F(DriveBackendSyncTest, LocalFileDeletionTest) {
592  std::string app_id = "example";
593  const base::FilePath::StringType path(FPL("file"));
594
595  RegisterApp(app_id);
596  AddOrUpdateLocalFile(app_id, path, "abcde");
597
598  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
599  VerifyConsistency();
600
601  RemoveLocal(app_id, path);
602
603  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
604  VerifyConsistency();
605
606  EXPECT_EQ(1u, CountApp());
607  EXPECT_EQ(1u, CountLocalFile(app_id));
608
609  EXPECT_EQ(2u, CountMetadata());
610  EXPECT_EQ(2u, CountTracker());
611}
612
613TEST_F(DriveBackendSyncTest, RemoteFileDeletionTest) {
614  std::string app_id = "example";
615  const base::FilePath::StringType path(FPL("file"));
616
617  RegisterApp(app_id);
618  AddOrUpdateLocalFile(app_id, path, "abcde");
619
620  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
621  VerifyConsistency();
622
623  std::string file_id = GetFileIDByPath(app_id, path);
624  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
625            fake_drive_service_helper()->DeleteResource(file_id));
626
627  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
628  VerifyConsistency();
629
630  EXPECT_EQ(1u, CountApp());
631  EXPECT_EQ(1u, CountLocalFile(app_id));
632
633  EXPECT_EQ(2u, CountMetadata());
634  EXPECT_EQ(2u, CountTracker());
635}
636
637TEST_F(DriveBackendSyncTest, RemoteRenameTest) {
638  std::string app_id = "example";
639  const base::FilePath::StringType path(FPL("file"));
640
641  RegisterApp(app_id);
642  AddOrUpdateLocalFile(app_id, path, "abcde");
643
644  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
645  VerifyConsistency();
646
647  std::string file_id = GetFileIDByPath(app_id, path);
648  EXPECT_EQ(google_apis::HTTP_SUCCESS,
649            fake_drive_service_helper()->RenameResource(
650                file_id, "renamed_file"));
651
652  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
653  VerifyConsistency();
654
655  EXPECT_EQ(1u, CountApp());
656  EXPECT_EQ(2u, CountLocalFile(app_id));
657  VerifyLocalFile(app_id, FPL("renamed_file"), "abcde");
658
659  EXPECT_EQ(3u, CountMetadata());
660  EXPECT_EQ(3u, CountTracker());
661}
662
663TEST_F(DriveBackendSyncTest, RemoteRenameAndRevertTest) {
664  std::string app_id = "example";
665  const base::FilePath::StringType path(FPL("file"));
666
667  RegisterApp(app_id);
668  AddOrUpdateLocalFile(app_id, path, "abcde");
669
670  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
671  VerifyConsistency();
672
673  std::string file_id = GetFileIDByPath(app_id, path);
674  EXPECT_EQ(google_apis::HTTP_SUCCESS,
675            fake_drive_service_helper()->RenameResource(
676                file_id, "renamed_file"));
677
678  FetchRemoteChanges();
679
680  EXPECT_EQ(google_apis::HTTP_SUCCESS,
681            fake_drive_service_helper()->RenameResource(
682                file_id, base::FilePath(path).AsUTF8Unsafe()));
683
684  FetchRemoteChanges();
685
686  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
687  VerifyConsistency();
688
689  EXPECT_EQ(1u, CountApp());
690  EXPECT_EQ(2u, CountLocalFile(app_id));
691  VerifyLocalFile(app_id, FPL("file"), "abcde");
692
693  EXPECT_EQ(3u, CountMetadata());
694  EXPECT_EQ(3u, CountTracker());
695}
696
697TEST_F(DriveBackendSyncTest, ReorganizeToOtherFolder) {
698  std::string app_id = "example";
699  const base::FilePath::StringType path(FPL("file"));
700
701  RegisterApp(app_id);
702  AddLocalFolder(app_id, FPL("folder_src"));
703  AddLocalFolder(app_id, FPL("folder_dest"));
704  AddOrUpdateLocalFile(app_id, FPL("folder_src/file"), "abcde");
705
706  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
707  VerifyConsistency();
708
709  std::string file_id = GetFileIDByPath(app_id, FPL("folder_src/file"));
710  std::string src_folder_id = GetFileIDByPath(app_id, FPL("folder_src"));
711  std::string dest_folder_id = GetFileIDByPath(app_id, FPL("folder_dest"));
712  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
713            fake_drive_service_helper()->RemoveResourceFromDirectory(
714                src_folder_id, file_id));
715  EXPECT_EQ(google_apis::HTTP_SUCCESS,
716            fake_drive_service_helper()->AddResourceToDirectory(
717                dest_folder_id, file_id));
718
719  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
720  VerifyConsistency();
721
722  EXPECT_EQ(1u, CountApp());
723  EXPECT_EQ(4u, CountLocalFile(app_id));
724  VerifyLocalFolder(app_id, FPL("folder_dest"));
725  VerifyLocalFile(app_id, FPL("folder_dest/file"), "abcde");
726
727  EXPECT_EQ(5u, CountMetadata());
728  EXPECT_EQ(5u, CountTracker());
729}
730
731TEST_F(DriveBackendSyncTest, ReorganizeToOtherApp) {
732  std::string src_app_id = "src_app";
733  std::string dest_app_id = "dest_app";
734
735  RegisterApp(src_app_id);
736  RegisterApp(dest_app_id);
737
738  AddLocalFolder(src_app_id, FPL("folder_src"));
739  AddLocalFolder(dest_app_id, FPL("folder_dest"));
740  AddOrUpdateLocalFile(src_app_id, FPL("folder_src/file"), "abcde");
741
742  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
743  VerifyConsistency();
744
745  std::string file_id = GetFileIDByPath(src_app_id, FPL("folder_src/file"));
746  std::string src_folder_id = GetFileIDByPath(src_app_id, FPL("folder_src"));
747  std::string dest_folder_id = GetFileIDByPath(dest_app_id, FPL("folder_dest"));
748  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
749            fake_drive_service_helper()->RemoveResourceFromDirectory(
750                src_folder_id, file_id));
751  EXPECT_EQ(google_apis::HTTP_SUCCESS,
752            fake_drive_service_helper()->AddResourceToDirectory(
753                dest_folder_id, file_id));
754
755  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
756  VerifyConsistency();
757
758  EXPECT_EQ(2u, CountApp());
759  EXPECT_EQ(2u, CountLocalFile(src_app_id));
760  EXPECT_EQ(3u, CountLocalFile(dest_app_id));
761  VerifyLocalFile(dest_app_id, FPL("folder_dest/file"), "abcde");
762
763  EXPECT_EQ(6u, CountMetadata());
764  EXPECT_EQ(6u, CountTracker());
765}
766
767TEST_F(DriveBackendSyncTest, ReorganizeToUnmanagedArea) {
768  std::string app_id = "example";
769
770  RegisterApp(app_id);
771
772  AddLocalFolder(app_id, FPL("folder_src"));
773  AddOrUpdateLocalFile(app_id, FPL("folder_src/file_orphaned"), "abcde");
774  AddOrUpdateLocalFile(app_id, FPL("folder_src/file_under_sync_root"), "123");
775  AddOrUpdateLocalFile(app_id, FPL("folder_src/file_under_drive_root"), "hoge");
776
777  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
778  VerifyConsistency();
779
780  std::string file_orphaned_id =
781      GetFileIDByPath(app_id, FPL("folder_src/file_orphaned"));
782  std::string file_under_sync_root_id =
783      GetFileIDByPath(app_id, FPL("folder_src/file_under_sync_root"));
784  std::string file_under_drive_root_id =
785      GetFileIDByPath(app_id, FPL("folder_src/file_under_drive_root"));
786
787  std::string folder_id = GetFileIDByPath(app_id, FPL("folder_src"));
788  std::string sync_root_folder_id;
789  EXPECT_EQ(google_apis::HTTP_SUCCESS,
790            fake_drive_service_helper()->GetSyncRootFolderID(
791                &sync_root_folder_id));
792
793  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
794            fake_drive_service_helper()->RemoveResourceFromDirectory(
795                folder_id, file_orphaned_id));
796  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
797            fake_drive_service_helper()->RemoveResourceFromDirectory(
798                folder_id, file_under_sync_root_id));
799  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
800            fake_drive_service_helper()->RemoveResourceFromDirectory(
801                folder_id, file_under_drive_root_id));
802
803  EXPECT_EQ(google_apis::HTTP_SUCCESS,
804            fake_drive_service_helper()->AddResourceToDirectory(
805                sync_root_folder_id, file_under_sync_root_id));
806  EXPECT_EQ(google_apis::HTTP_SUCCESS,
807            fake_drive_service_helper()->AddResourceToDirectory(
808                fake_drive_service()->GetRootResourceId(),
809                file_under_drive_root_id));
810
811  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
812  VerifyConsistency();
813
814  EXPECT_EQ(1u, CountApp());
815  EXPECT_EQ(2u, CountLocalFile(app_id));
816
817  EXPECT_EQ(4u, CountMetadata());
818  EXPECT_EQ(4u, CountTracker());
819}
820
821TEST_F(DriveBackendSyncTest, ReorganizeToMultipleParents) {
822  std::string app_id = "example";
823
824  RegisterApp(app_id);
825
826  AddLocalFolder(app_id, FPL("parent1"));
827  AddLocalFolder(app_id, FPL("parent2"));
828  AddOrUpdateLocalFile(app_id, FPL("parent1/file"), "abcde");
829
830  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
831  VerifyConsistency();
832
833  std::string file_id = GetFileIDByPath(app_id, FPL("parent1/file"));
834  std::string parent2_folder_id = GetFileIDByPath(app_id, FPL("parent2"));
835  EXPECT_EQ(google_apis::HTTP_SUCCESS,
836            fake_drive_service_helper()->AddResourceToDirectory(
837                parent2_folder_id, file_id));
838
839  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
840  VerifyConsistency();
841
842  EXPECT_EQ(1u, CountApp());
843  EXPECT_EQ(4u, CountLocalFile(app_id));
844  VerifyLocalFolder(app_id, FPL("parent1"));
845  VerifyLocalFolder(app_id, FPL("parent2"));
846  VerifyLocalFile(app_id, FPL("parent1/file"), "abcde");
847
848  EXPECT_EQ(5u, CountMetadata());
849  EXPECT_EQ(5u, CountTracker());
850}
851
852TEST_F(DriveBackendSyncTest, ReorganizeAndRevert) {
853  std::string app_id = "example";
854
855  RegisterApp(app_id);
856
857  AddLocalFolder(app_id, FPL("folder"));
858  AddLocalFolder(app_id, FPL("folder_temp"));
859  AddOrUpdateLocalFile(app_id, FPL("folder/file"), "abcde");
860
861  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
862  VerifyConsistency();
863
864  std::string file_id = GetFileIDByPath(app_id, FPL("folder/file"));
865  std::string folder_id = GetFileIDByPath(app_id, FPL("folder"));
866  std::string folder_temp_id = GetFileIDByPath(app_id, FPL("folder_temp"));
867  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
868            fake_drive_service_helper()->RemoveResourceFromDirectory(
869                folder_id, file_id));
870  EXPECT_EQ(google_apis::HTTP_SUCCESS,
871            fake_drive_service_helper()->AddResourceToDirectory(
872                folder_temp_id, file_id));
873
874  FetchRemoteChanges();
875
876  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
877            fake_drive_service_helper()->RemoveResourceFromDirectory(
878                folder_temp_id, file_id));
879  EXPECT_EQ(google_apis::HTTP_SUCCESS,
880            fake_drive_service_helper()->AddResourceToDirectory(
881                folder_id, file_id));
882
883  FetchRemoteChanges();
884
885  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
886  VerifyConsistency();
887
888  EXPECT_EQ(1u, CountApp());
889  EXPECT_EQ(4u, CountLocalFile(app_id));
890  VerifyLocalFolder(app_id, FPL("folder"));
891  VerifyLocalFile(app_id, FPL("folder/file"), "abcde");
892
893  EXPECT_EQ(5u, CountMetadata());
894  EXPECT_EQ(5u, CountTracker());
895}
896
897TEST_F(DriveBackendSyncTest, ConflictTest_AddFolder_AddFolder) {
898  std::string app_id = "example";
899
900  RegisterApp(app_id);
901  std::string app_root_folder_id = GetFileIDByPath(app_id, FPL(""));
902
903  AddLocalFolder(app_id, FPL("conflict_to_pending_remote"));
904  AddLocalFolder(app_id, FPL("conflict_to_existing_remote"));
905
906  std::string remote_folder_id;
907  EXPECT_EQ(google_apis::HTTP_CREATED,
908            fake_drive_service_helper()->AddFolder(
909                app_root_folder_id,
910                "conflict_to_pending_remote", &remote_folder_id));
911
912  FetchRemoteChanges();
913
914  EXPECT_EQ(google_apis::HTTP_CREATED,
915            fake_drive_service_helper()->AddFolder(
916                app_root_folder_id,
917                "conflict_to_existing_remote", &remote_folder_id));
918
919  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
920  VerifyConsistency();
921
922  EXPECT_EQ(1u, CountApp());
923  EXPECT_EQ(3u, CountLocalFile(app_id));
924  VerifyLocalFolder(app_id, FPL("conflict_to_pending_remote"));
925  VerifyLocalFolder(app_id, FPL("conflict_to_existing_remote"));
926
927  EXPECT_EQ(4u, CountMetadata());
928  EXPECT_EQ(4u, CountTracker());
929}
930
931TEST_F(DriveBackendSyncTest, ConflictTest_AddFolder_DeleteFolder) {
932  std::string app_id = "example";
933
934  RegisterApp(app_id);
935
936  AddLocalFolder(app_id, FPL("conflict_to_pending_remote"));
937  AddLocalFolder(app_id, FPL("conflict_to_existing_remote"));
938
939  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
940  VerifyConsistency();
941
942  // Test body starts from here.
943  RemoveLocal(app_id, FPL("conflict_to_pending_remote"));
944  AddLocalFolder(app_id, FPL("conflict_to_pending_remote"));
945  RemoveLocal(app_id, FPL("conflict_to_existing_remote"));
946  AddLocalFolder(app_id, FPL("conflict_to_existing_remote"));
947
948  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
949            fake_drive_service_helper()->DeleteResource(
950                GetFileIDByPath(app_id, FPL("conflict_to_pending_remote"))));
951
952  FetchRemoteChanges();
953
954  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
955            fake_drive_service_helper()->DeleteResource(
956                GetFileIDByPath(app_id, FPL("conflict_to_existing_remote"))));
957
958  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
959  VerifyConsistency();
960
961  EXPECT_EQ(1u, CountApp());
962  EXPECT_EQ(2u, CountLocalFile(app_id));
963  VerifyLocalFolder(app_id, FPL("conflict_to_pending_remote"));
964
965  EXPECT_EQ(3u, CountMetadata());
966  EXPECT_EQ(3u, CountTracker());
967}
968
969TEST_F(DriveBackendSyncTest, ConflictTest_AddFolder_AddFile) {
970  std::string app_id = "example";
971
972  RegisterApp(app_id);
973  std::string app_root_folder_id = GetFileIDByPath(app_id, FPL(""));
974
975  AddLocalFolder(app_id, FPL("conflict_to_pending_remote"));
976  AddLocalFolder(app_id, FPL("conflict_to_existing_remote"));
977
978  std::string file_id;
979  EXPECT_EQ(google_apis::HTTP_SUCCESS,
980            fake_drive_service_helper()->AddFile(
981                app_root_folder_id, "conflict_to_pending_remote", "foo",
982                &file_id));
983  EXPECT_EQ(google_apis::HTTP_SUCCESS,
984            fake_drive_service_helper()->UpdateModificationTime(
985                file_id,
986                base::Time::Now() + base::TimeDelta::FromDays(1)));
987
988  FetchRemoteChanges();
989
990  EXPECT_EQ(google_apis::HTTP_SUCCESS,
991            fake_drive_service_helper()->AddFile(
992                app_root_folder_id, "conflict_to_existing_remote", "foo",
993                &file_id));
994  EXPECT_EQ(google_apis::HTTP_SUCCESS,
995            fake_drive_service_helper()->UpdateModificationTime(
996                file_id,
997                base::Time::Now() + base::TimeDelta::FromDays(1)));
998
999  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1000  VerifyConsistency();
1001
1002  EXPECT_EQ(1u, CountApp());
1003  EXPECT_EQ(3u, CountLocalFile(app_id));
1004  VerifyLocalFolder(app_id, FPL("conflict_to_pending_remote"));
1005  VerifyLocalFolder(app_id, FPL("conflict_to_existing_remote"));
1006
1007  EXPECT_EQ(4u, CountMetadata());
1008  EXPECT_EQ(4u, CountTracker());
1009}
1010
1011TEST_F(DriveBackendSyncTest, ConflictTest_AddFolder_DeleteFile) {
1012  std::string app_id = "example";
1013
1014  RegisterApp(app_id);
1015  std::string app_root_folder_id = GetFileIDByPath(app_id, FPL(""));
1016
1017  AddOrUpdateLocalFile(app_id, FPL("conflict_to_pending_remote"), "foo");
1018  AddOrUpdateLocalFile(app_id, FPL("conflict_to_existing_remote"), "bar");
1019
1020  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1021  VerifyConsistency();
1022
1023  // Test body starts from here.
1024  RemoveLocal(app_id, FPL("conflict_to_pending_remote"));
1025  AddLocalFolder(app_id, FPL("conflict_to_pending_remote"));
1026
1027  RemoveLocal(app_id, FPL("conflict_to_existing_remote"));
1028  AddLocalFolder(app_id, FPL("conflict_to_existing_remote"));
1029
1030  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
1031            fake_drive_service_helper()->DeleteResource(
1032                GetFileIDByPath(app_id, FPL("conflict_to_pending_remote"))));
1033
1034  FetchRemoteChanges();
1035
1036  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
1037            fake_drive_service_helper()->DeleteResource(
1038                GetFileIDByPath(app_id, FPL("conflict_to_existing_remote"))));
1039
1040  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1041  VerifyConsistency();
1042
1043  EXPECT_EQ(1u, CountApp());
1044  EXPECT_EQ(3u, CountLocalFile(app_id));
1045  VerifyLocalFolder(app_id, FPL("conflict_to_pending_remote"));
1046  VerifyLocalFolder(app_id, FPL("conflict_to_existing_remote"));
1047
1048  EXPECT_EQ(4u, CountMetadata());
1049  EXPECT_EQ(4u, CountTracker());
1050}
1051
1052TEST_F(DriveBackendSyncTest, ConflictTest_DeleteFolder_AddFolder) {
1053  std::string app_id = "example";
1054
1055  RegisterApp(app_id);
1056  std::string app_root_folder_id = GetFileIDByPath(app_id, FPL(""));
1057  AddLocalFolder(app_id, FPL("conflict_to_pending_remote"));
1058  AddLocalFolder(app_id, FPL("conflict_to_existing_remote"));
1059
1060  RemoveLocal(app_id, FPL("conflict_to_pending_remote"));
1061  RemoveLocal(app_id, FPL("conflict_to_existing_remote"));
1062
1063  std::string file_id;
1064  EXPECT_EQ(google_apis::HTTP_CREATED,
1065            fake_drive_service_helper()->AddFolder(
1066                app_root_folder_id,
1067                "conflict_to_pending_remote", &file_id));
1068
1069  FetchRemoteChanges();
1070
1071  EXPECT_EQ(google_apis::HTTP_CREATED,
1072            fake_drive_service_helper()->AddFolder(
1073                app_root_folder_id,
1074                "conflict_to_existing_remote", NULL));
1075
1076  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1077  VerifyConsistency();
1078
1079  EXPECT_EQ(1u, CountApp());
1080  EXPECT_EQ(3u, CountLocalFile(app_id));
1081  VerifyLocalFolder(app_id, FPL("conflict_to_pending_remote"));
1082  VerifyLocalFolder(app_id, FPL("conflict_to_existing_remote"));
1083
1084  EXPECT_EQ(4u, CountMetadata());
1085  EXPECT_EQ(4u, CountTracker());
1086}
1087
1088TEST_F(DriveBackendSyncTest, ConflictTest_DeleteFolder_DeleteFolder) {
1089  std::string app_id = "example";
1090
1091  RegisterApp(app_id);
1092  std::string app_root_folder_id = GetFileIDByPath(app_id, FPL(""));
1093
1094  AddLocalFolder(app_id, FPL("conflict_to_pending_remote"));
1095  AddLocalFolder(app_id, FPL("conflict_to_existing_remote"));
1096
1097  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1098  VerifyConsistency();
1099
1100  // Test body starts from here.
1101  RemoveLocal(app_id, FPL("conflict_to_pending_remote"));
1102  RemoveLocal(app_id, FPL("conflict_to_existing_remote"));
1103
1104  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
1105            fake_drive_service_helper()->DeleteResource(
1106                GetFileIDByPath(app_id, FPL("conflict_to_pending_remote"))));
1107
1108  FetchRemoteChanges();
1109
1110  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
1111            fake_drive_service_helper()->DeleteResource(
1112                GetFileIDByPath(app_id, FPL("conflict_to_existing_remote"))));
1113
1114  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1115  VerifyConsistency();
1116
1117  EXPECT_EQ(1u, CountApp());
1118  EXPECT_EQ(1u, CountLocalFile(app_id));
1119
1120  EXPECT_EQ(2u, CountMetadata());
1121  EXPECT_EQ(2u, CountTracker());
1122}
1123
1124TEST_F(DriveBackendSyncTest, ConflictTest_DeleteFolder_AddFile) {
1125  std::string app_id = "example";
1126
1127  RegisterApp(app_id);
1128  std::string app_root_folder_id = GetFileIDByPath(app_id, FPL(""));
1129
1130  AddLocalFolder(app_id, FPL("conflict_to_pending_remote"));
1131  AddLocalFolder(app_id, FPL("conflict_to_existing_remote"));
1132  RemoveLocal(app_id, FPL("conflict_to_pending_remote"));
1133  RemoveLocal(app_id, FPL("conflict_to_existing_remote"));
1134
1135  EXPECT_EQ(google_apis::HTTP_SUCCESS,
1136            fake_drive_service_helper()->AddFile(
1137                app_root_folder_id, "conflict_to_pending_remote", "foo", NULL));
1138
1139  FetchRemoteChanges();
1140
1141  EXPECT_EQ(google_apis::HTTP_SUCCESS,
1142            fake_drive_service_helper()->AddFile(
1143                app_root_folder_id, "conflict_to_existing_remote", "bar",
1144                NULL));
1145
1146  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1147  VerifyConsistency();
1148
1149  EXPECT_EQ(1u, CountApp());
1150  EXPECT_EQ(3u, CountLocalFile(app_id));
1151  VerifyLocalFile(app_id, FPL("conflict_to_pending_remote"), "foo");
1152  VerifyLocalFile(app_id, FPL("conflict_to_existing_remote"), "bar");
1153
1154  EXPECT_EQ(4u, CountMetadata());
1155  EXPECT_EQ(4u, CountTracker());
1156}
1157
1158TEST_F(DriveBackendSyncTest, ConflictTest_DeleteFolder_DeleteFile) {
1159  std::string app_id = "example";
1160
1161  RegisterApp(app_id);
1162  std::string app_root_folder_id = GetFileIDByPath(app_id, FPL(""));
1163  AddOrUpdateLocalFile(app_id, FPL("conflict_to_pending_remote"), "foo");
1164  AddOrUpdateLocalFile(app_id, FPL("conflict_to_existing_remote"), "bar");
1165
1166  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1167  VerifyConsistency();
1168
1169  // Test body starts from here.
1170  RemoveLocal(app_id, FPL("conflict_to_pending_remote"));
1171  RemoveLocal(app_id, FPL("conflict_to_existing_remote"));
1172
1173  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
1174            fake_drive_service_helper()->DeleteResource(
1175                GetFileIDByPath(app_id, FPL("conflict_to_pending_remote"))));
1176
1177  FetchRemoteChanges();
1178
1179  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
1180            fake_drive_service_helper()->DeleteResource(
1181                GetFileIDByPath(app_id, FPL("conflict_to_existing_remote"))));
1182
1183  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1184  VerifyConsistency();
1185
1186  EXPECT_EQ(1u, CountApp());
1187  EXPECT_EQ(1u, CountLocalFile(app_id));
1188
1189  EXPECT_EQ(2u, CountMetadata());
1190  EXPECT_EQ(2u, CountTracker());
1191}
1192
1193TEST_F(DriveBackendSyncTest, ConflictTest_AddFile_AddFolder) {
1194  std::string app_id = "example";
1195
1196  RegisterApp(app_id);
1197  std::string app_root_folder_id = GetFileIDByPath(app_id, FPL(""));
1198
1199  AddOrUpdateLocalFile(app_id, FPL("conflict_to_pending_remote"), "foo");
1200  AddOrUpdateLocalFile(app_id, FPL("conflict_to_existing_remote"), "bar");
1201
1202  std::string file_id;
1203  EXPECT_EQ(google_apis::HTTP_CREATED,
1204            fake_drive_service_helper()->AddFolder(
1205                app_root_folder_id, "conflict_to_pending_remote",
1206                &file_id));
1207  EXPECT_EQ(google_apis::HTTP_SUCCESS,
1208            fake_drive_service_helper()->UpdateModificationTime(
1209                file_id,
1210                base::Time::Now() - base::TimeDelta::FromDays(1)));
1211
1212  FetchRemoteChanges();
1213
1214  EXPECT_EQ(google_apis::HTTP_CREATED,
1215            fake_drive_service_helper()->AddFolder(
1216                app_root_folder_id, "conflict_to_existing_remote",
1217                &file_id));
1218  EXPECT_EQ(google_apis::HTTP_SUCCESS,
1219            fake_drive_service_helper()->UpdateModificationTime(
1220                file_id,
1221                base::Time::Now() - base::TimeDelta::FromDays(1)));
1222
1223  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1224  VerifyConsistency();
1225
1226  EXPECT_EQ(1u, CountApp());
1227  EXPECT_EQ(3u, CountLocalFile(app_id));
1228  VerifyLocalFolder(app_id, FPL("conflict_to_pending_remote"));
1229  VerifyLocalFolder(app_id, FPL("conflict_to_existing_remote"));
1230
1231  EXPECT_EQ(4u, CountMetadata());
1232  EXPECT_EQ(4u, CountTracker());
1233}
1234
1235TEST_F(DriveBackendSyncTest, ConflictTest_AddFile_DeleteFolder) {
1236  std::string app_id = "example";
1237
1238  RegisterApp(app_id);
1239  std::string app_root_folder_id = GetFileIDByPath(app_id, FPL(""));
1240
1241  AddLocalFolder(app_id, FPL("conflict_to_pending_remote"));
1242  AddLocalFolder(app_id, FPL("conflict_to_existing_remote"));
1243
1244  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1245  VerifyConsistency();
1246
1247  // Test body starts from here.
1248  RemoveLocal(app_id, FPL("conflict_to_pending_remote"));
1249  RemoveLocal(app_id, FPL("conflict_to_existing_remote"));
1250  AddOrUpdateLocalFile(app_id, FPL("conflict_to_pending_remote"), "foo");
1251  AddOrUpdateLocalFile(app_id, FPL("conflict_to_existing_remote"), "bar");
1252
1253  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
1254            fake_drive_service_helper()->DeleteResource(
1255                GetFileIDByPath(app_id, FPL("conflict_to_pending_remote"))));
1256
1257  FetchRemoteChanges();
1258
1259  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
1260            fake_drive_service_helper()->DeleteResource(
1261                GetFileIDByPath(app_id, FPL("conflict_to_existing_remote"))));
1262
1263  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1264  VerifyConsistency();
1265
1266  EXPECT_EQ(1u, CountApp());
1267  EXPECT_EQ(3u, CountLocalFile(app_id));
1268  VerifyLocalFile(app_id, FPL("conflict_to_pending_remote"), "foo");
1269  VerifyLocalFile(app_id, FPL("conflict_to_existing_remote"), "bar");
1270
1271  EXPECT_EQ(4u, CountMetadata());
1272  EXPECT_EQ(4u, CountTracker());
1273}
1274
1275TEST_F(DriveBackendSyncTest, ConflictTest_AddFile_AddFile) {
1276  std::string app_id = "example";
1277
1278  RegisterApp(app_id);
1279
1280  std::string app_root_folder_id = GetFileIDByPath(app_id, FPL(""));
1281  AddOrUpdateLocalFile(app_id, FPL("conflict_to_pending_remote"), "hoge");
1282  AddOrUpdateLocalFile(app_id, FPL("conflict_to_existing_remote"), "fuga");
1283
1284  std::string file_id;
1285  EXPECT_EQ(google_apis::HTTP_SUCCESS,
1286            fake_drive_service_helper()->AddFile(
1287                app_root_folder_id, "conflict_to_pending_remote", "foo",
1288                &file_id));
1289  EXPECT_EQ(google_apis::HTTP_SUCCESS,
1290            fake_drive_service_helper()->UpdateModificationTime(
1291                file_id,
1292                base::Time::Now() + base::TimeDelta::FromDays(1)));
1293
1294  FetchRemoteChanges();
1295
1296  EXPECT_EQ(google_apis::HTTP_SUCCESS,
1297            fake_drive_service_helper()->AddFile(
1298                app_root_folder_id, "conflict_to_existing_remote", "bar",
1299                &file_id));
1300  EXPECT_EQ(google_apis::HTTP_SUCCESS,
1301            fake_drive_service_helper()->UpdateModificationTime(
1302                file_id,
1303                base::Time::Now() + base::TimeDelta::FromDays(1)));
1304
1305  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1306  VerifyConsistency();
1307
1308  EXPECT_EQ(1u, CountApp());
1309  EXPECT_EQ(3u, CountLocalFile(app_id));
1310  VerifyLocalFile(app_id, FPL("conflict_to_pending_remote"), "foo");
1311  VerifyLocalFile(app_id, FPL("conflict_to_existing_remote"), "bar");
1312
1313  EXPECT_EQ(4u, CountMetadata());
1314  EXPECT_EQ(4u, CountTracker());
1315}
1316
1317TEST_F(DriveBackendSyncTest, ConflictTest_AddFile_DeleteFile) {
1318  std::string app_id = "example";
1319
1320  RegisterApp(app_id);
1321
1322  AddOrUpdateLocalFile(app_id, FPL("conflict_to_pending_remote"), "foo");
1323  AddOrUpdateLocalFile(app_id, FPL("conflict_to_existing_remote"), "bar");
1324
1325  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1326  VerifyConsistency();
1327
1328  // Test body starts from here.
1329  RemoveLocal(app_id, FPL("conflict_to_pending_remote"));
1330  RemoveLocal(app_id, FPL("conflict_to_existing_remote"));
1331  AddOrUpdateLocalFile(app_id, FPL("conflict_to_pending_remote"), "hoge");
1332  AddOrUpdateLocalFile(app_id, FPL("conflict_to_existing_remote"), "fuga");
1333
1334  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
1335            fake_drive_service_helper()->DeleteResource(
1336                GetFileIDByPath(app_id, FPL("conflict_to_pending_remote"))));
1337
1338  FetchRemoteChanges();
1339
1340  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
1341            fake_drive_service_helper()->DeleteResource(
1342                GetFileIDByPath(app_id, FPL("conflict_to_existing_remote"))));
1343
1344  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1345  VerifyConsistency();
1346
1347  EXPECT_EQ(1u, CountApp());
1348  EXPECT_EQ(3u, CountLocalFile(app_id));
1349  VerifyLocalFile(app_id, FPL("conflict_to_pending_remote"), "hoge");
1350  VerifyLocalFile(app_id, FPL("conflict_to_existing_remote"), "fuga");
1351
1352  EXPECT_EQ(4u, CountMetadata());
1353  EXPECT_EQ(4u, CountTracker());
1354}
1355
1356TEST_F(DriveBackendSyncTest, ConflictTest_UpdateFile_DeleteFile) {
1357  std::string app_id = "example";
1358
1359  RegisterApp(app_id);
1360
1361  AddOrUpdateLocalFile(app_id, FPL("conflict_to_pending_remote"), "foo");
1362  AddOrUpdateLocalFile(app_id, FPL("conflict_to_existing_remote"), "bar");
1363
1364  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1365  VerifyConsistency();
1366
1367  // Test body starts from here.
1368  AddOrUpdateLocalFile(app_id, FPL("conflict_to_pending_remote"), "hoge");
1369  AddOrUpdateLocalFile(app_id, FPL("conflict_to_existing_remote"), "fuga");
1370
1371  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
1372            fake_drive_service_helper()->DeleteResource(
1373                GetFileIDByPath(app_id, FPL("conflict_to_pending_remote"))));
1374
1375  FetchRemoteChanges();
1376
1377  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
1378            fake_drive_service_helper()->DeleteResource(
1379                GetFileIDByPath(app_id, FPL("conflict_to_existing_remote"))));
1380
1381  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1382  VerifyConsistency();
1383
1384  EXPECT_EQ(1u, CountApp());
1385  EXPECT_EQ(3u, CountLocalFile(app_id));
1386  VerifyLocalFile(app_id, FPL("conflict_to_pending_remote"), "hoge");
1387  VerifyLocalFile(app_id, FPL("conflict_to_existing_remote"), "fuga");
1388
1389  EXPECT_EQ(4u, CountMetadata());
1390  EXPECT_EQ(4u, CountTracker());
1391}
1392
1393TEST_F(DriveBackendSyncTest, ConflictTest_DeleteFile_AddFolder) {
1394  std::string app_id = "example";
1395
1396  RegisterApp(app_id);
1397
1398  std::string app_root_folder_id = GetFileIDByPath(app_id, FPL(""));
1399  AddOrUpdateLocalFile(app_id, FPL("conflict_to_pending_remote"), "foo");
1400  AddOrUpdateLocalFile(app_id, FPL("conflict_to_existing_remote"), "bar");
1401
1402  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1403  VerifyConsistency();
1404
1405  // Test body starts from here.
1406  RemoveLocal(app_id, FPL("conflict_to_pending_remote"));
1407  RemoveLocal(app_id, FPL("conflict_to_existing_remote"));
1408
1409  EXPECT_EQ(google_apis::HTTP_CREATED,
1410            fake_drive_service_helper()->AddFolder(
1411                app_root_folder_id, "conflict_to_pending_remote", NULL));
1412
1413  FetchRemoteChanges();
1414
1415  EXPECT_EQ(google_apis::HTTP_CREATED,
1416            fake_drive_service_helper()->AddFolder(
1417                app_root_folder_id, "conflict_to_existing_remote", NULL));
1418
1419  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1420  VerifyConsistency();
1421
1422  EXPECT_EQ(1u, CountApp());
1423  EXPECT_EQ(3u, CountLocalFile(app_id));
1424  VerifyLocalFolder(app_id, FPL("conflict_to_pending_remote"));
1425  VerifyLocalFolder(app_id, FPL("conflict_to_existing_remote"));
1426
1427  EXPECT_EQ(4u, CountMetadata());
1428  EXPECT_EQ(4u, CountTracker());
1429}
1430
1431TEST_F(DriveBackendSyncTest, ConflictTest_DeleteFile_DeleteFolder) {
1432  std::string app_id = "example";
1433
1434  RegisterApp(app_id);
1435
1436  AddLocalFolder(app_id, FPL("conflict_to_pending_remote"));
1437  AddLocalFolder(app_id, FPL("conflict_to_existing_remote"));
1438
1439  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1440  VerifyConsistency();
1441
1442  // Test body starts from here.
1443  RemoveLocal(app_id, FPL("conflict_to_pending_remote"));
1444  RemoveLocal(app_id, FPL("conflict_to_existing_remote"));
1445
1446  AddOrUpdateLocalFile(app_id, FPL("conflict_to_pending_remote"), "foo");
1447  AddOrUpdateLocalFile(app_id, FPL("conflict_to_existing_remote"), "bar");
1448
1449  RemoveLocal(app_id, FPL("conflict_to_pending_remote"));
1450  RemoveLocal(app_id, FPL("conflict_to_existing_remote"));
1451
1452  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
1453            fake_drive_service_helper()->DeleteResource(
1454                GetFileIDByPath(app_id, FPL("conflict_to_pending_remote"))));
1455
1456  FetchRemoteChanges();
1457
1458  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
1459            fake_drive_service_helper()->DeleteResource(
1460                GetFileIDByPath(app_id, FPL("conflict_to_existing_remote"))));
1461
1462  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1463  VerifyConsistency();
1464
1465  EXPECT_EQ(1u, CountApp());
1466  EXPECT_EQ(1u, CountLocalFile(app_id));
1467
1468  EXPECT_EQ(2u, CountMetadata());
1469  EXPECT_EQ(2u, CountTracker());
1470}
1471
1472TEST_F(DriveBackendSyncTest, ConflictTest_DeleteFile_AddFile) {
1473  std::string app_id = "example";
1474
1475  RegisterApp(app_id);
1476
1477  std::string app_root_folder_id = GetFileIDByPath(app_id, FPL(""));
1478  AddOrUpdateLocalFile(app_id, FPL("conflict_to_pending_remote"), "foo");
1479  AddOrUpdateLocalFile(app_id, FPL("conflict_to_existing_remote"), "bar");
1480  RemoveLocal(app_id, FPL("conflict_to_pending_remote"));
1481  RemoveLocal(app_id, FPL("conflict_to_existing_remote"));
1482
1483  EXPECT_EQ(google_apis::HTTP_SUCCESS,
1484            fake_drive_service_helper()->AddFile(
1485                app_root_folder_id, "conflict_to_pending_remote", "hoge",
1486                NULL));
1487
1488  FetchRemoteChanges();
1489
1490  EXPECT_EQ(google_apis::HTTP_SUCCESS,
1491            fake_drive_service_helper()->AddFile(
1492                app_root_folder_id, "conflict_to_existing_remote", "fuga",
1493                NULL));
1494
1495  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1496  VerifyConsistency();
1497
1498  EXPECT_EQ(1u, CountApp());
1499  EXPECT_EQ(3u, CountLocalFile(app_id));
1500  VerifyLocalFile(app_id, FPL("conflict_to_pending_remote"), "hoge");
1501  VerifyLocalFile(app_id, FPL("conflict_to_existing_remote"), "fuga");
1502
1503  EXPECT_EQ(4u, CountMetadata());
1504  EXPECT_EQ(4u, CountTracker());
1505}
1506
1507TEST_F(DriveBackendSyncTest, ConflictTest_DeleteFile_UpdateFile) {
1508  std::string app_id = "example";
1509
1510  RegisterApp(app_id);
1511
1512  std::string app_root_folder_id = GetFileIDByPath(app_id, FPL(""));
1513  AddOrUpdateLocalFile(app_id, FPL("conflict_to_pending_remote"), "foo");
1514  AddOrUpdateLocalFile(app_id, FPL("conflict_to_existing_remote"), "bar");
1515
1516  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1517  VerifyConsistency();
1518
1519  // Test body starts from here.
1520  RemoveLocal(app_id, FPL("conflict_to_pending_remote"));
1521  RemoveLocal(app_id, FPL("conflict_to_existing_remote"));
1522
1523  EXPECT_EQ(google_apis::HTTP_SUCCESS,
1524            fake_drive_service_helper()->UpdateFile(
1525                GetFileIDByPath(app_id, FPL("conflict_to_pending_remote")),
1526                "hoge"));
1527
1528  FetchRemoteChanges();
1529
1530  EXPECT_EQ(google_apis::HTTP_SUCCESS,
1531            fake_drive_service_helper()->UpdateFile(
1532                GetFileIDByPath(app_id, FPL("conflict_to_existing_remote")),
1533                "fuga"));
1534
1535  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1536  VerifyConsistency();
1537
1538  EXPECT_EQ(1u, CountApp());
1539  EXPECT_EQ(3u, CountLocalFile(app_id));
1540  VerifyLocalFile(app_id, FPL("conflict_to_pending_remote"), "hoge");
1541  VerifyLocalFile(app_id, FPL("conflict_to_existing_remote"), "fuga");
1542
1543  EXPECT_EQ(4u, CountMetadata());
1544  EXPECT_EQ(4u, CountTracker());
1545}
1546
1547TEST_F(DriveBackendSyncTest, ConflictTest_DeleteFile_DeleteFile) {
1548  std::string app_id = "example";
1549
1550  RegisterApp(app_id);
1551
1552  std::string app_root_folder_id = GetFileIDByPath(app_id, FPL(""));
1553  AddOrUpdateLocalFile(app_id, FPL("conflict_to_pending_remote"), "foo");
1554  AddOrUpdateLocalFile(app_id, FPL("conflict_to_existing_remote"), "bar");
1555
1556  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1557  VerifyConsistency();
1558
1559  // Test body starts from here.
1560  RemoveLocal(app_id, FPL("conflict_to_pending_remote"));
1561  RemoveLocal(app_id, FPL("conflict_to_existing_remote"));
1562
1563  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
1564            fake_drive_service_helper()->DeleteResource(
1565                GetFileIDByPath(app_id, FPL("conflict_to_pending_remote"))));
1566
1567  FetchRemoteChanges();
1568
1569  EXPECT_EQ(google_apis::HTTP_NO_CONTENT,
1570            fake_drive_service_helper()->DeleteResource(
1571                GetFileIDByPath(app_id, FPL("conflict_to_existing_remote"))));
1572
1573  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
1574  VerifyConsistency();
1575
1576  EXPECT_EQ(1u, CountApp());
1577  EXPECT_EQ(1u, CountLocalFile(app_id));
1578
1579  EXPECT_EQ(2u, CountMetadata());
1580  EXPECT_EQ(2u, CountTracker());
1581}
1582
1583}  // namespace drive_backend
1584}  // namespace sync_file_system
1585