chrome/browser/sync_file_system/local/local_file_sync_service_unittest.cc

   1 // Copyright 2013 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 <vector>
   6
   7 #include "base/basictypes.h"
   8 #include "base/bind.h"
   9 #include "base/files/file_util.h"
  10 #include "base/location.h"
  11 #include "base/run_loop.h"
  12 #include "base/stl_util.h"
  13 #include "base/thread_task_runner_handle.h"
  14 #include "base/threading/thread.h"
  15 #include "chrome/browser/sync_file_system/file_change.h"
  16 #include "chrome/browser/sync_file_system/local/canned_syncable_file_system.h"
  17 #include "chrome/browser/sync_file_system/local/local_file_change_tracker.h"
  18 #include "chrome/browser/sync_file_system/local/local_file_sync_context.h"
  19 #include "chrome/browser/sync_file_system/local/local_file_sync_service.h"
  20 #include "chrome/browser/sync_file_system/local/local_file_sync_status.h"
  21 #include "chrome/browser/sync_file_system/local/mock_sync_status_observer.h"
  22 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h"
  23 #include "chrome/browser/sync_file_system/mock_local_change_processor.h"
  24 #include "chrome/browser/sync_file_system/sync_file_metadata.h"
  25 #include "chrome/browser/sync_file_system/sync_file_system_test_util.h"
  26 #include "chrome/browser/sync_file_system/sync_status_code.h"
  27 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
  28 #include "chrome/test/base/testing_profile.h"
  29 #include "content/public/browser/browser_thread.h"
  30 #include "content/public/test/test_browser_thread_bundle.h"
  31 #include "content/public/test/test_utils.h"
  32 #include "storage/browser/fileapi/file_system_context.h"
  33 #include "testing/gmock/include/gmock/gmock.h"
  34 #include "testing/gtest/include/gtest/gtest.h"
  35 #include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
  36 #include "third_party/leveldatabase/src/include/leveldb/env.h"
  37
  38 using content::BrowserThread;
  39 using storage::FileSystemURL;
  40 using ::testing::_;
  41 using ::testing::AtLeast;
  42 using ::testing::InvokeWithoutArgs;
  43 using ::testing::StrictMock;
  44
  45 namespace sync_file_system {
  46
  47 namespace {
  48
  49 const char kOrigin[] = "http://example.com";
  50
  51 void DidPrepareForProcessRemoteChange(const tracked_objects::Location& where,
  52                                       const base::Closure& oncompleted,
  53                                       SyncStatusCode expected_status,
  54                                       const SyncFileMetadata& expected_metadata,
  55                                       SyncStatusCode status,
  56                                       const SyncFileMetadata& metadata,
  57                                       const FileChangeList& changes) {
  58   SCOPED_TRACE(testing::Message() << where.ToString());
  59   ASSERT_EQ(expected_status, status);
  60   ASSERT_EQ(expected_metadata.file_type, metadata.file_type);
  61   ASSERT_EQ(expected_metadata.size, metadata.size);
  62   ASSERT_TRUE(changes.empty());
  63   oncompleted.Run();
  64 }
  65
  66 void OnSyncCompleted(const tracked_objects::Location& where,
  67                      const base::Closure& oncompleted,
  68                      SyncStatusCode expected_status,
  69                      const FileSystemURL& expected_url,
  70                      SyncStatusCode status,
  71                      const FileSystemURL& url) {
  72   SCOPED_TRACE(testing::Message() << where.ToString());
  73   ASSERT_EQ(expected_status, status);
  74   ASSERT_EQ(expected_url, url);
  75   oncompleted.Run();
  76 }
  77
  78 void OnGetFileMetadata(const tracked_objects::Location& where,
  79                        const base::Closure& oncompleted,
  80                        SyncStatusCode* status_out,
  81                        SyncFileMetadata* metadata_out,
  82                        SyncStatusCode status,
  83                        const SyncFileMetadata& metadata) {
  84   SCOPED_TRACE(testing::Message() << where.ToString());
  85   *status_out = status;
  86   *metadata_out = metadata;
  87   oncompleted.Run();
  88 }
  89
  90 ACTION_P(MockStatusCallback, status) {
  91   base::ThreadTaskRunnerHandle::Get()->PostTask(
  92       FROM_HERE, base::Bind(arg4, status));
  93 }
  94
  95 ACTION_P2(MockStatusCallbackAndRecordChange, status, changes) {
  96   base::ThreadTaskRunnerHandle::Get()->PostTask(
  97       FROM_HERE, base::Bind(arg4, status));
  98   changes->push_back(arg0);
  99 }
 100
 101 }  // namespace
 102
 103 class LocalFileSyncServiceTest
 104     : public testing::Test,
 105       public LocalFileSyncService::Observer {
 106  protected:
 107   LocalFileSyncServiceTest()
 108       : thread_bundle_(content::TestBrowserThreadBundle::REAL_FILE_THREAD |
 109                        content::TestBrowserThreadBundle::REAL_IO_THREAD),
 110         num_changes_(0) {}
 111
 112   void SetUp() override {
 113     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 114     in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
 115
 116     file_system_.reset(new CannedSyncableFileSystem(
 117         GURL(kOrigin),
 118         in_memory_env_.get(),
 119         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
 120         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)));
 121
 122     local_service_ = LocalFileSyncService::CreateForTesting(
 123         &profile_, in_memory_env_.get());
 124
 125     file_system_->SetUp(CannedSyncableFileSystem::QUOTA_ENABLED);
 126
 127     base::RunLoop run_loop;
 128     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
 129     local_service_->MaybeInitializeFileSystemContext(
 130         GURL(kOrigin), file_system_->file_system_context(),
 131         AssignAndQuitCallback(&run_loop, &status));
 132     run_loop.Run();
 133
 134     local_service_->AddChangeObserver(this);
 135
 136     EXPECT_EQ(base::File::FILE_OK, file_system_->OpenFileSystem());
 137
 138     file_system_->backend()->sync_context()->
 139         set_mock_notify_changes_duration_in_sec(0);
 140   }
 141
 142   void TearDown() override {
 143     local_service_->Shutdown();
 144     file_system_->TearDown();
 145     RevokeSyncableFileSystem();
 146     content::RunAllPendingInMessageLoop(BrowserThread::FILE);
 147     content::RunAllPendingInMessageLoop(BrowserThread::IO);
 148   }
 149
 150   // LocalChangeObserver overrides.
 151   void OnLocalChangeAvailable(int64 num_changes) override {
 152     num_changes_ = num_changes;
 153   }
 154
 155   void PrepareForProcessRemoteChange(
 156       const FileSystemURL& url,
 157       const tracked_objects::Location& where,
 158       SyncStatusCode expected_status,
 159       const SyncFileMetadata& expected_metadata) {
 160     base::RunLoop run_loop;
 161     local_service_->PrepareForProcessRemoteChange(
 162         url,
 163         base::Bind(&DidPrepareForProcessRemoteChange,
 164                    where,
 165                    run_loop.QuitClosure(),
 166                    expected_status,
 167                    expected_metadata));
 168     run_loop.Run();
 169   }
 170
 171   SyncStatusCode ApplyRemoteChange(const FileChange& change,
 172                                    const base::FilePath& local_path,
 173                                    const FileSystemURL& url) {
 174     SyncStatusCode sync_status = SYNC_STATUS_UNKNOWN;
 175     {
 176       base::RunLoop run_loop;
 177       local_service_->ApplyRemoteChange(
 178           change, local_path, url,
 179           AssignAndQuitCallback(&run_loop, &sync_status));
 180       run_loop.Run();
 181     }
 182     {
 183       base::RunLoop run_loop;
 184       local_service_->FinalizeRemoteSync(
 185           url,
 186           sync_status == SYNC_STATUS_OK,
 187           run_loop.QuitClosure());
 188       run_loop.Run();
 189     }
 190     return sync_status;
 191   }
 192
 193   int64 GetNumChangesInTracker() const {
 194     return file_system_->backend()->change_tracker()->num_changes();
 195   }
 196
 197   content::TestBrowserThreadBundle thread_bundle_;
 198
 199   base::ScopedTempDir temp_dir_;
 200   scoped_ptr<leveldb::Env> in_memory_env_;
 201   TestingProfile profile_;
 202
 203   scoped_ptr<CannedSyncableFileSystem> file_system_;
 204   scoped_ptr<LocalFileSyncService> local_service_;
 205
 206   int64 num_changes_;
 207 };
 208
 209 // More complete tests for PrepareForProcessRemoteChange and ApplyRemoteChange
 210 // are also in content_unittest:LocalFileSyncContextTest.
 211 TEST_F(LocalFileSyncServiceTest, RemoteSyncStepsSimple) {
 212   const FileSystemURL kFile(file_system_->URL("file"));
 213   const FileSystemURL kDir(file_system_->URL("dir"));
 214   const char kTestFileData[] = "0123456789";
 215   const int kTestFileDataSize = static_cast<int>(arraysize(kTestFileData) - 1);
 216
 217   base::FilePath local_path;
 218   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &local_path));
 219   ASSERT_EQ(kTestFileDataSize,
 220             base::WriteFile(local_path, kTestFileData, kTestFileDataSize));
 221
 222   // Run PrepareForProcessRemoteChange for kFile.
 223   SyncFileMetadata expected_metadata;
 224   expected_metadata.file_type = SYNC_FILE_TYPE_UNKNOWN;
 225   expected_metadata.size = 0;
 226   PrepareForProcessRemoteChange(kFile, FROM_HERE,
 227                                 SYNC_STATUS_OK,
 228                                 expected_metadata);
 229
 230   // Run ApplyRemoteChange for kFile.
 231   FileChange change(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
 232                     SYNC_FILE_TYPE_FILE);
 233   EXPECT_EQ(SYNC_STATUS_OK,
 234             ApplyRemoteChange(change, local_path, kFile));
 235
 236   // Verify the file is synced.
 237   EXPECT_EQ(base::File::FILE_OK,
 238             file_system_->VerifyFile(kFile, kTestFileData));
 239
 240   // Run PrepareForProcessRemoteChange for kDir.
 241   PrepareForProcessRemoteChange(kDir, FROM_HERE,
 242                                 SYNC_STATUS_OK,
 243                                 expected_metadata);
 244
 245   // Run ApplyRemoteChange for kDir.
 246   change = FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
 247                       SYNC_FILE_TYPE_DIRECTORY);
 248   EXPECT_EQ(SYNC_STATUS_OK,
 249             ApplyRemoteChange(change, base::FilePath(), kDir));
 250
 251   // Verify the directory.
 252   EXPECT_EQ(base::File::FILE_OK,
 253             file_system_->DirectoryExists(kDir));
 254
 255   // Run PrepareForProcessRemoteChange and ApplyRemoteChange for
 256   // kDir once again for deletion.
 257   expected_metadata.file_type = SYNC_FILE_TYPE_DIRECTORY;
 258   expected_metadata.size = 0;
 259   PrepareForProcessRemoteChange(kDir, FROM_HERE,
 260                                 SYNC_STATUS_OK,
 261                                 expected_metadata);
 262
 263   change = FileChange(FileChange::FILE_CHANGE_DELETE, SYNC_FILE_TYPE_UNKNOWN);
 264   EXPECT_EQ(SYNC_STATUS_OK, ApplyRemoteChange(change, base::FilePath(), kDir));
 265
 266   // Now the directory must have deleted.
 267   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
 268             file_system_->DirectoryExists(kDir));
 269 }
 270
 271 TEST_F(LocalFileSyncServiceTest, LocalChangeObserver) {
 272   const FileSystemURL kFile(file_system_->URL("file"));
 273   const FileSystemURL kDir(file_system_->URL("dir"));
 274   const char kTestFileData[] = "0123456789";
 275   const int kTestFileDataSize = static_cast<int>(arraysize(kTestFileData) - 1);
 276
 277   EXPECT_EQ(base::File::FILE_OK, file_system_->CreateFile(kFile));
 278
 279   EXPECT_EQ(1, num_changes_);
 280
 281   EXPECT_EQ(base::File::FILE_OK, file_system_->CreateDirectory(kDir));
 282   EXPECT_EQ(kTestFileDataSize,
 283             file_system_->WriteString(kFile, kTestFileData));
 284
 285   EXPECT_EQ(2, num_changes_);
 286 }
 287
 288 #if defined(OS_WIN)
 289 // Flaky: http://crbug.com/171487
 290 #define MAYBE_LocalChangeObserverMultipleContexts\
 291     DISABLED_LocalChangeObserverMultipleContexts
 292 #else
 293 #define MAYBE_LocalChangeObserverMultipleContexts\
 294     LocalChangeObserverMultipleContexts
 295 #endif
 296
 297 TEST_F(LocalFileSyncServiceTest, MAYBE_LocalChangeObserverMultipleContexts) {
 298   const char kOrigin2[] = "http://foo";
 299   CannedSyncableFileSystem file_system2(
 300       GURL(kOrigin2),
 301       in_memory_env_.get(),
 302       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
 303       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
 304   file_system2.SetUp(CannedSyncableFileSystem::QUOTA_ENABLED);
 305
 306   base::RunLoop run_loop;
 307   SyncStatusCode status = SYNC_STATUS_UNKNOWN;
 308   local_service_->MaybeInitializeFileSystemContext(
 309       GURL(kOrigin2), file_system2.file_system_context(),
 310       AssignAndQuitCallback(&run_loop, &status));
 311   run_loop.Run();
 312
 313   EXPECT_EQ(base::File::FILE_OK, file_system2.OpenFileSystem());
 314   file_system2.backend()->sync_context()->
 315       set_mock_notify_changes_duration_in_sec(0);
 316
 317   const FileSystemURL kFile1(file_system_->URL("file1"));
 318   const FileSystemURL kFile2(file_system_->URL("file2"));
 319   const FileSystemURL kFile3(file_system2.URL("file3"));
 320   const FileSystemURL kFile4(file_system2.URL("file4"));
 321
 322   EXPECT_EQ(base::File::FILE_OK, file_system_->CreateFile(kFile1));
 323   EXPECT_EQ(base::File::FILE_OK, file_system_->CreateFile(kFile2));
 324   EXPECT_EQ(base::File::FILE_OK, file_system2.CreateFile(kFile3));
 325   EXPECT_EQ(base::File::FILE_OK, file_system2.CreateFile(kFile4));
 326
 327   EXPECT_EQ(4, num_changes_);
 328
 329   file_system2.TearDown();
 330 }
 331
 332 TEST_F(LocalFileSyncServiceTest, ProcessLocalChange_CreateFile) {
 333   const FileSystemURL kFile(file_system_->URL("foo"));
 334   const char kTestFileData[] = "0123456789";
 335   const int kTestFileDataSize = static_cast<int>(arraysize(kTestFileData) - 1);
 336
 337   base::RunLoop run_loop;
 338
 339   // We should get called OnSyncEnabled and OnWriteEnabled on kFile.
 340   // (OnWriteEnabled is called because we release lock before returning
 341   // from ApplyLocalChange)
 342   StrictMock<MockSyncStatusObserver> status_observer;
 343   EXPECT_CALL(status_observer, OnSyncEnabled(kFile)).Times(AtLeast(1));
 344   EXPECT_CALL(status_observer, OnWriteEnabled(kFile)).Times(AtLeast(0));
 345   file_system_->AddSyncStatusObserver(&status_observer);
 346
 347   // Creates and writes into a file.
 348   EXPECT_EQ(base::File::FILE_OK, file_system_->CreateFile(kFile));
 349   EXPECT_EQ(kTestFileDataSize,
 350             file_system_->WriteString(kFile, std::string(kTestFileData)));
 351
 352   // Retrieve the expected file info.
 353   base::File::Info info;
 354   base::FilePath platform_path;
 355   EXPECT_EQ(base::File::FILE_OK,
 356             file_system_->GetMetadataAndPlatformPath(
 357                 kFile, &info, &platform_path));
 358
 359   ASSERT_FALSE(info.is_directory);
 360   ASSERT_EQ(kTestFileDataSize, info.size);
 361
 362   SyncFileMetadata metadata;
 363   metadata.file_type = SYNC_FILE_TYPE_FILE;
 364   metadata.size = info.size;
 365   metadata.last_modified = info.last_modified;
 366
 367   // The local_change_processor's ApplyLocalChange should be called once
 368   // with ADD_OR_UPDATE change for TYPE_FILE.
 369   StrictMock<MockLocalChangeProcessor> local_change_processor;
 370   const FileChange change(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
 371                           SYNC_FILE_TYPE_FILE);
 372   EXPECT_CALL(local_change_processor,
 373               ApplyLocalChange(change, _, metadata, kFile, _))
 374       .WillOnce(MockStatusCallback(SYNC_STATUS_OK));
 375
 376   local_service_->SetLocalChangeProcessor(&local_change_processor);
 377   local_service_->ProcessLocalChange(
 378       base::Bind(&OnSyncCompleted, FROM_HERE, run_loop.QuitClosure(),
 379                  SYNC_STATUS_OK, kFile));
 380
 381   run_loop.Run();
 382
 383   file_system_->RemoveSyncStatusObserver(&status_observer);
 384
 385   EXPECT_EQ(0, GetNumChangesInTracker());
 386 }
 387
 388 TEST_F(LocalFileSyncServiceTest, ProcessLocalChange_CreateAndRemoveFile) {
 389   const FileSystemURL kFile(file_system_->URL("foo"));
 390
 391   base::RunLoop run_loop;
 392
 393   // We should get called OnSyncEnabled and possibly OnWriteEnabled (depends
 394   // on timing) on kFile.
 395   StrictMock<MockSyncStatusObserver> status_observer;
 396   EXPECT_CALL(status_observer, OnSyncEnabled(kFile)).Times(AtLeast(1));
 397   EXPECT_CALL(status_observer, OnWriteEnabled(kFile)).Times(AtLeast(0));
 398   file_system_->AddSyncStatusObserver(&status_observer);
 399
 400   // Creates and then deletes a file.
 401   EXPECT_EQ(base::File::FILE_OK, file_system_->CreateFile(kFile));
 402   EXPECT_EQ(base::File::FILE_OK, file_system_->Remove(kFile, false));
 403
 404   // The local_change_processor's ApplyLocalChange should be called once
 405   // with DELETE change for TYPE_FILE.
 406   // The file will NOT exist in the remote side and the processor might
 407   // return SYNC_FILE_ERROR_NOT_FOUND (as mocked).
 408   StrictMock<MockLocalChangeProcessor> local_change_processor;
 409   const FileChange change(FileChange::FILE_CHANGE_DELETE, SYNC_FILE_TYPE_FILE);
 410   EXPECT_CALL(local_change_processor, ApplyLocalChange(change, _, _, kFile, _))
 411       .WillOnce(MockStatusCallback(SYNC_FILE_ERROR_NOT_FOUND));
 412
 413   // The sync should succeed anyway.
 414   local_service_->SetLocalChangeProcessor(&local_change_processor);
 415   local_service_->ProcessLocalChange(
 416       base::Bind(&OnSyncCompleted, FROM_HERE, run_loop.QuitClosure(),
 417                  SYNC_STATUS_OK, kFile));
 418
 419   run_loop.Run();
 420
 421   file_system_->RemoveSyncStatusObserver(&status_observer);
 422
 423   EXPECT_EQ(0, GetNumChangesInTracker());
 424 }
 425
 426 TEST_F(LocalFileSyncServiceTest, ProcessLocalChange_CreateAndRemoveDirectory) {
 427   const FileSystemURL kDir(file_system_->URL("foo"));
 428
 429   base::RunLoop run_loop;
 430
 431   // OnSyncEnabled is expected to be called at least or more than once.
 432   StrictMock<MockSyncStatusObserver> status_observer;
 433   EXPECT_CALL(status_observer, OnSyncEnabled(kDir)).Times(AtLeast(1));
 434   file_system_->AddSyncStatusObserver(&status_observer);
 435
 436   // Creates and then deletes a directory.
 437   EXPECT_EQ(base::File::FILE_OK, file_system_->CreateDirectory(kDir));
 438   EXPECT_EQ(base::File::FILE_OK, file_system_->Remove(kDir, false));
 439
 440   // The local_change_processor's ApplyLocalChange should never be called.
 441   StrictMock<MockLocalChangeProcessor> local_change_processor;
 442
 443   local_service_->SetLocalChangeProcessor(&local_change_processor);
 444   local_service_->ProcessLocalChange(
 445       base::Bind(&OnSyncCompleted, FROM_HERE, run_loop.QuitClosure(),
 446                  SYNC_STATUS_NO_CHANGE_TO_SYNC, FileSystemURL()));
 447
 448   run_loop.Run();
 449
 450   file_system_->RemoveSyncStatusObserver(&status_observer);
 451
 452   EXPECT_EQ(0, GetNumChangesInTracker());
 453 }
 454
 455 TEST_F(LocalFileSyncServiceTest, ProcessLocalChange_MultipleChanges) {
 456   const FileSystemURL kPath(file_system_->URL("foo"));
 457   const FileSystemURL kOther(file_system_->URL("bar"));
 458
 459   base::RunLoop run_loop;
 460
 461   // We should get called OnSyncEnabled and OnWriteEnabled on kPath and
 462   // OnSyncEnabled on kOther.
 463   StrictMock<MockSyncStatusObserver> status_observer;
 464   EXPECT_CALL(status_observer, OnSyncEnabled(kPath)).Times(AtLeast(1));
 465   EXPECT_CALL(status_observer, OnSyncEnabled(kOther)).Times(AtLeast(1));
 466   file_system_->AddSyncStatusObserver(&status_observer);
 467
 468   // Creates a file, delete the file and creates a directory with the same
 469   // name.
 470   EXPECT_EQ(base::File::FILE_OK, file_system_->CreateFile(kPath));
 471   EXPECT_EQ(base::File::FILE_OK, file_system_->Remove(kPath, false));
 472   EXPECT_EQ(base::File::FILE_OK, file_system_->CreateDirectory(kPath));
 473
 474   // Creates one more file.
 475   EXPECT_EQ(base::File::FILE_OK, file_system_->CreateFile(kOther));
 476
 477   // The local_change_processor's ApplyLocalChange will be called
 478   // twice for FILE_TYPE and FILE_DIRECTORY.
 479   StrictMock<MockLocalChangeProcessor> local_change_processor;
 480   std::vector<FileChange> changes;
 481   EXPECT_CALL(local_change_processor, ApplyLocalChange(_, _, _, kPath, _))
 482       .Times(2)
 483       .WillOnce(MockStatusCallbackAndRecordChange(SYNC_STATUS_OK, &changes))
 484       .WillOnce(MockStatusCallbackAndRecordChange(SYNC_STATUS_OK, &changes));
 485   local_service_->SetLocalChangeProcessor(&local_change_processor);
 486
 487   // OnWriteEnabled will be notified on kPath (in multi-threaded this
 488   // could be delayed, so AtLeast(0)).
 489   EXPECT_CALL(status_observer, OnWriteEnabled(kPath)).Times(AtLeast(0));
 490
 491   local_service_->ProcessLocalChange(
 492       base::Bind(&OnSyncCompleted, FROM_HERE, run_loop.QuitClosure(),
 493                  SYNC_STATUS_OK, kPath));
 494
 495   run_loop.Run();
 496
 497   EXPECT_EQ(2U, changes.size());
 498   EXPECT_EQ(FileChange(FileChange::FILE_CHANGE_DELETE, SYNC_FILE_TYPE_FILE),
 499             changes[0]);
 500   EXPECT_EQ(FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
 501                        SYNC_FILE_TYPE_DIRECTORY),
 502             changes[1]);
 503
 504   file_system_->RemoveSyncStatusObserver(&status_observer);
 505
 506   // We have one more change for kOther.
 507   EXPECT_EQ(1, GetNumChangesInTracker());
 508 }
 509
 510 TEST_F(LocalFileSyncServiceTest, ProcessLocalChange_GetLocalMetadata) {
 511   const FileSystemURL kURL(file_system_->URL("foo"));
 512   const base::Time kTime = base::Time::FromDoubleT(333);
 513   const int kSize = 555;
 514
 515   base::RunLoop run_loop;
 516
 517   // Creates a file.
 518   EXPECT_EQ(base::File::FILE_OK, file_system_->CreateFile(kURL));
 519   EXPECT_EQ(base::File::FILE_OK, file_system_->TruncateFile(kURL, kSize));
 520   EXPECT_EQ(base::File::FILE_OK,
 521             file_system_->TouchFile(kURL, base::Time(), kTime));
 522
 523   SyncStatusCode status = SYNC_STATUS_UNKNOWN;
 524   SyncFileMetadata metadata;
 525   local_service_->GetLocalFileMetadata(
 526       kURL,
 527       base::Bind(&OnGetFileMetadata, FROM_HERE, run_loop.QuitClosure(),
 528                  &status, &metadata));
 529
 530   run_loop.Run();
 531
 532   EXPECT_EQ(SYNC_STATUS_OK, status);
 533   EXPECT_EQ(kTime, metadata.last_modified);
 534   EXPECT_EQ(kSize, metadata.size);
 535 }
 536
 537 TEST_F(LocalFileSyncServiceTest, RecordFakeChange) {
 538   const FileSystemURL kURL(file_system_->URL("foo"));
 539
 540   // Create a file and reset the changes (as preparation).
 541   EXPECT_EQ(base::File::FILE_OK, file_system_->CreateFile(kURL));
 542   file_system_->ClearChangeForURLInTracker(kURL);
 543
 544   EXPECT_EQ(0, GetNumChangesInTracker());
 545
 546   storage::FileSystemURLSet urlset;
 547   file_system_->GetChangedURLsInTracker(&urlset);
 548   EXPECT_TRUE(urlset.empty());
 549
 550   const FileChange change(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
 551                           SYNC_FILE_TYPE_FILE);
 552
 553   // Call RecordFakeLocalChange to add an ADD_OR_UPDATE change.
 554   {
 555     base::RunLoop run_loop;
 556     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
 557     local_service_->RecordFakeLocalChange(
 558         kURL, change, AssignAndQuitCallback(&run_loop, &status));
 559     run_loop.Run();
 560     EXPECT_EQ(SYNC_STATUS_OK, status);
 561   }
 562
 563   EXPECT_EQ(1, GetNumChangesInTracker());
 564   file_system_->GetChangedURLsInTracker(&urlset);
 565   EXPECT_EQ(1U, urlset.size());
 566   EXPECT_TRUE(urlset.find(kURL) != urlset.end());
 567
 568   // Next local sync should pick up the recorded change.
 569   StrictMock<MockLocalChangeProcessor> local_change_processor;
 570   std::vector<FileChange> changes;
 571   EXPECT_CALL(local_change_processor, ApplyLocalChange(_, _, _, kURL, _))
 572       .WillOnce(MockStatusCallbackAndRecordChange(SYNC_STATUS_OK, &changes));
 573   {
 574     base::RunLoop run_loop;
 575     local_service_->SetLocalChangeProcessor(&local_change_processor);
 576     local_service_->ProcessLocalChange(
 577         base::Bind(&OnSyncCompleted, FROM_HERE, run_loop.QuitClosure(),
 578                    SYNC_STATUS_OK, kURL));
 579     run_loop.Run();
 580   }
 581
 582   EXPECT_EQ(1U, changes.size());
 583   EXPECT_EQ(change, changes[0]);
 584 }
 585
 586 // TODO(kinuko): Add tests for multiple file changes and multiple
 587 // FileSystemContexts.
 588
 589 // Unit test for OriginChangeMap ---------------------------------------------
 590
 591 class OriginChangeMapTest : public testing::Test {
 592  protected:
 593   OriginChangeMapTest() {}
 594   ~OriginChangeMapTest() override {}
 595
 596   bool NextOriginToProcess(GURL* origin) {
 597     return map_.NextOriginToProcess(origin);
 598   }
 599
 600   int64 GetTotalChangeCount() const {
 601     return map_.GetTotalChangeCount();
 602   }
 603
 604   void SetOriginChangeCount(const GURL& origin, int64 changes) {
 605     map_.SetOriginChangeCount(origin, changes);
 606   }
 607
 608   void SetOriginEnabled(const GURL& origin, bool enabled) {
 609     map_.SetOriginEnabled(origin, enabled);
 610   }
 611
 612   LocalFileSyncService::OriginChangeMap map_;
 613 };
 614
 615 TEST_F(OriginChangeMapTest, Basic) {
 616   const GURL kOrigin1("chrome-extension://foo");
 617   const GURL kOrigin2("chrome-extension://bar");
 618   const GURL kOrigin3("chrome-extension://baz");
 619
 620   ASSERT_EQ(0, GetTotalChangeCount());
 621
 622   SetOriginChangeCount(kOrigin1, 1);
 623   SetOriginChangeCount(kOrigin2, 2);
 624
 625   ASSERT_EQ(1 + 2, GetTotalChangeCount());
 626
 627   SetOriginChangeCount(kOrigin3, 4);
 628
 629   ASSERT_EQ(1 + 2 + 4, GetTotalChangeCount());
 630
 631   const GURL kOrigins[] = { kOrigin1, kOrigin2, kOrigin3 };
 632   std::set<GURL> all_origins;
 633   all_origins.insert(kOrigins, kOrigins + arraysize(kOrigins));
 634
 635   GURL origin;
 636   while (!all_origins.empty()) {
 637     ASSERT_TRUE(NextOriginToProcess(&origin));
 638     ASSERT_TRUE(ContainsKey(all_origins, origin));
 639     all_origins.erase(origin);
 640   }
 641
 642   // Set kOrigin2's change count 0.
 643   SetOriginChangeCount(kOrigin2, 0);
 644   ASSERT_EQ(1 + 4, GetTotalChangeCount());
 645
 646   // kOrigin2 won't return this time.
 647   all_origins.insert(kOrigin1);
 648   all_origins.insert(kOrigin3);
 649   while (!all_origins.empty()) {
 650     ASSERT_TRUE(NextOriginToProcess(&origin));
 651     ASSERT_TRUE(ContainsKey(all_origins, origin));
 652     all_origins.erase(origin);
 653   }
 654
 655   // Calling NextOriginToProcess() again will just return
 656   // the same set of origins (as far as we don't change the
 657   // change count).
 658   all_origins.insert(kOrigin1);
 659   all_origins.insert(kOrigin3);
 660   while (!all_origins.empty()) {
 661     ASSERT_TRUE(NextOriginToProcess(&origin));
 662     ASSERT_TRUE(ContainsKey(all_origins, origin));
 663     all_origins.erase(origin);
 664   }
 665
 666   // Set kOrigin2's change count 8.
 667   SetOriginChangeCount(kOrigin2, 8);
 668   ASSERT_EQ(1 + 4 + 8, GetTotalChangeCount());
 669
 670   all_origins.insert(kOrigins, kOrigins + arraysize(kOrigins));
 671   while (!all_origins.empty()) {
 672     ASSERT_TRUE(NextOriginToProcess(&origin));
 673     ASSERT_TRUE(ContainsKey(all_origins, origin));
 674     all_origins.erase(origin);
 675   }
 676 }
 677
 678 TEST_F(OriginChangeMapTest, WithDisabled) {
 679   const GURL kOrigin1("chrome-extension://foo");
 680   const GURL kOrigin2("chrome-extension://bar");
 681   const GURL kOrigin3("chrome-extension://baz");
 682   const GURL kOrigins[] = { kOrigin1, kOrigin2, kOrigin3 };
 683
 684   ASSERT_EQ(0, GetTotalChangeCount());
 685
 686   SetOriginChangeCount(kOrigin1, 1);
 687   SetOriginChangeCount(kOrigin2, 2);
 688   SetOriginChangeCount(kOrigin3, 4);
 689
 690   ASSERT_EQ(1 + 2 + 4, GetTotalChangeCount());
 691
 692   std::set<GURL> all_origins;
 693   all_origins.insert(kOrigins, kOrigins + arraysize(kOrigins));
 694
 695   GURL origin;
 696   while (!all_origins.empty()) {
 697     ASSERT_TRUE(NextOriginToProcess(&origin));
 698     ASSERT_TRUE(ContainsKey(all_origins, origin));
 699     all_origins.erase(origin);
 700   }
 701
 702   SetOriginEnabled(kOrigin2, false);
 703   ASSERT_EQ(1 + 4, GetTotalChangeCount());
 704
 705   // kOrigin2 won't return this time.
 706   all_origins.insert(kOrigin1);
 707   all_origins.insert(kOrigin3);
 708   while (!all_origins.empty()) {
 709     ASSERT_TRUE(NextOriginToProcess(&origin));
 710     ASSERT_TRUE(ContainsKey(all_origins, origin));
 711     all_origins.erase(origin);
 712   }
 713
 714   // kOrigin1 and kOrigin2 are now disabled.
 715   SetOriginEnabled(kOrigin1, false);
 716   ASSERT_EQ(4, GetTotalChangeCount());
 717
 718   ASSERT_TRUE(NextOriginToProcess(&origin));
 719   ASSERT_EQ(kOrigin3, origin);
 720
 721   // Re-enable kOrigin2.
 722   SetOriginEnabled(kOrigin2, true);
 723   ASSERT_EQ(2 + 4, GetTotalChangeCount());
 724
 725   // kOrigin1 won't return this time.
 726   all_origins.insert(kOrigin2);
 727   all_origins.insert(kOrigin3);
 728   while (!all_origins.empty()) {
 729     ASSERT_TRUE(NextOriginToProcess(&origin));
 730     ASSERT_TRUE(ContainsKey(all_origins, origin));
 731     all_origins.erase(origin);
 732   }
 733 }
 734
 735 }  // namespace sync_file_system