Home | History | Annotate | Download | only in sync_file_system 
      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 <vector>
      6 
      7 #include "base/basictypes.h"
      8 #include "base/bind.h"
      9 #include "base/run_loop.h"
     10 #include "base/stl_util.h"
     11 #include "base/synchronization/waitable_event.h"
     12 #include "chrome/browser/sync_file_system/local/canned_syncable_file_system.h"
     13 #include "chrome/browser/sync_file_system/local/local_file_sync_context.h"
     14 #include "chrome/browser/sync_file_system/local/local_file_sync_service.h"
     15 #include "chrome/browser/sync_file_system/local/mock_sync_status_observer.h"
     16 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h"
     17 #include "chrome/browser/sync_file_system/mock_remote_file_sync_service.h"
     18 #include "chrome/browser/sync_file_system/sync_callbacks.h"
     19 #include "chrome/browser/sync_file_system/sync_event_observer.h"
     20 #include "chrome/browser/sync_file_system/sync_file_metadata.h"
     21 #include "chrome/browser/sync_file_system/sync_file_system_service.h"
     22 #include "chrome/browser/sync_file_system/sync_file_system_test_util.h"
     23 #include "chrome/browser/sync_file_system/sync_status_code.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/browser/browser_thread.h"
     27 #include "content/public/test/test_browser_thread_bundle.h"
     28 #include "content/public/test/test_utils.h"
     29 #include "testing/gtest/include/gtest/gtest.h"
     30 #include "webkit/browser/fileapi/file_system_context.h"
     31 
     32 using content::BrowserThread;
     33 using fileapi::FileSystemURL;
     34 using fileapi::FileSystemURLSet;
     35 using ::testing::AnyNumber;
     36 using ::testing::AtLeast;
     37 using ::testing::InSequence;
     38 using ::testing::InvokeWithoutArgs;
     39 using ::testing::Return;
     40 using ::testing::StrictMock;
     41 using ::testing::_;
     42 
     43 namespace sync_file_system {
     44 
     45 namespace {
     46 
     47 const char kOrigin[] = "http://example.com";
     48 
     49 template <typename R> struct AssignTrait {
     50   typedef const R& ArgumentType;
     51 };
     52 
     53 template <> struct AssignTrait<SyncFileStatus> {
     54   typedef SyncFileStatus ArgumentType;
     55 };
     56 
     57 template <typename R>
     58 void AssignValueAndQuit(base::RunLoop* run_loop,
     59                         SyncStatusCode* status_out, R* value_out,
     60                         SyncStatusCode status,
     61                         typename AssignTrait<R>::ArgumentType value) {
     62   DCHECK(status_out);
     63   DCHECK(value_out);
     64   DCHECK(run_loop);
     65   *status_out = status;
     66   *value_out = value;
     67   run_loop->Quit();
     68 }
     69 
     70 // This is called on IO thread.
     71 void VerifyFileError(base::RunLoop* run_loop,
     72                      base::PlatformFileError error) {
     73   DCHECK(run_loop);
     74   EXPECT_EQ(base::PLATFORM_FILE_OK, error);
     75   run_loop->Quit();
     76 }
     77 
     78 }  // namespace
     79 
     80 class MockSyncEventObserver : public SyncEventObserver {
     81  public:
     82   MockSyncEventObserver() {}
     83   virtual ~MockSyncEventObserver() {}
     84 
     85   MOCK_METHOD3(OnSyncStateUpdated,
     86                void(const GURL& app_origin,
     87                     SyncServiceState state,
     88                     const std::string& description));
     89   MOCK_METHOD4(OnFileSynced,
     90                void(const fileapi::FileSystemURL& url,
     91                     SyncFileStatus status,
     92                     SyncAction action,
     93                     SyncDirection direction));
     94 };
     95 
     96 ACTION_P3(NotifyStateAndCallback,
     97           mock_remote_service, service_state, operation_status) {
     98   mock_remote_service->NotifyRemoteServiceStateUpdated(
     99       service_state, "Test event.");
    100   base::MessageLoopProxy::current()->PostTask(
    101       FROM_HERE, base::Bind(arg1, operation_status));
    102 }
    103 
    104 ACTION_P(RecordState, states) {
    105   states->push_back(arg1);
    106 }
    107 
    108 ACTION_P(MockStatusCallback, status) {
    109   base::MessageLoopProxy::current()->PostTask(
    110       FROM_HERE, base::Bind(arg4, status));
    111 }
    112 
    113 ACTION_P2(MockSyncFileCallback, status, url) {
    114   base::MessageLoopProxy::current()->PostTask(
    115       FROM_HERE, base::Bind(arg0, status, url));
    116 }
    117 
    118 class SyncFileSystemServiceTest : public testing::Test {
    119  protected:
    120   SyncFileSystemServiceTest()
    121       : thread_bundle_(content::TestBrowserThreadBundle::REAL_FILE_THREAD |
    122                        content::TestBrowserThreadBundle::REAL_IO_THREAD) {}
    123 
    124   virtual void SetUp() OVERRIDE {
    125     file_system_.reset(new CannedSyncableFileSystem(
    126         GURL(kOrigin),
    127         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
    128         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)));
    129 
    130     local_service_ = new LocalFileSyncService(&profile_);
    131     remote_service_ = new StrictMock<MockRemoteFileSyncService>;
    132     sync_service_.reset(new SyncFileSystemService(&profile_));
    133 
    134     EXPECT_CALL(*mock_remote_service(),
    135                 AddServiceObserver(_)).Times(1);
    136     EXPECT_CALL(*mock_remote_service(),
    137                 AddFileStatusObserver(sync_service_.get())).Times(1);
    138     EXPECT_CALL(*mock_remote_service(),
    139                 GetLocalChangeProcessor())
    140         .WillRepeatedly(Return(&local_change_processor_));
    141     EXPECT_CALL(*mock_remote_service(),
    142                 SetRemoteChangeProcessor(local_service_)).Times(1);
    143 
    144     sync_service_->Initialize(
    145         make_scoped_ptr(local_service_),
    146         scoped_ptr<RemoteFileSyncService>(remote_service_));
    147 
    148     // Disable auto sync by default.
    149     EXPECT_CALL(*mock_remote_service(), SetSyncEnabled(false)).Times(1);
    150     sync_service_->SetSyncEnabledForTesting(false);
    151 
    152     file_system_->SetUp();
    153   }
    154 
    155   virtual void TearDown() OVERRIDE {
    156     sync_service_->Shutdown();
    157     file_system_->TearDown();
    158     RevokeSyncableFileSystem();
    159     content::RunAllPendingInMessageLoop(BrowserThread::FILE);
    160   }
    161 
    162   void InitializeApp() {
    163     base::RunLoop run_loop;
    164     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
    165 
    166     EXPECT_CALL(*mock_remote_service(),
    167                 RegisterOrigin(GURL(kOrigin), _)).Times(1);
    168 
    169     // GetCurrentState may be called when a remote or local sync is scheduled
    170     // by change notifications or by a timer.
    171     EXPECT_CALL(*mock_remote_service(), GetCurrentState())
    172         .Times(AnyNumber())
    173         .WillRepeatedly(Return(REMOTE_SERVICE_OK));
    174 
    175     sync_service_->InitializeForApp(
    176         file_system_->file_system_context(),
    177         GURL(kOrigin),
    178         AssignAndQuitCallback(&run_loop, &status));
    179     run_loop.Run();
    180 
    181     EXPECT_EQ(SYNC_STATUS_OK, status);
    182     EXPECT_EQ(base::PLATFORM_FILE_OK, file_system_->OpenFileSystem());
    183   }
    184 
    185   // Calls InitializeForApp after setting up the mock remote service to
    186   // perform following when RegisterOrigin is called:
    187   //  1. Notify RemoteFileSyncService's observers of |state_to_notify|
    188   //  2. Run the given callback with |status_to_return|.
    189   //
    190   // ..and verifies if following conditions are met:
    191   //  1. The SyncEventObserver of the service is called with
    192   //     |expected_states| service state values.
    193   //  2. InitializeForApp's callback is called with |expected_status|
    194   void InitializeAppForObserverTest(
    195       RemoteServiceState state_to_notify,
    196       SyncStatusCode status_to_return,
    197       const std::vector<SyncServiceState>& expected_states,
    198       SyncStatusCode expected_status) {
    199     StrictMock<MockSyncEventObserver> event_observer;
    200     sync_service_->AddSyncEventObserver(&event_observer);
    201 
    202     EnableSync();
    203 
    204     EXPECT_CALL(*mock_remote_service(), GetCurrentState())
    205         .Times(AnyNumber())
    206         .WillRepeatedly(Return(state_to_notify));
    207 
    208     EXPECT_CALL(*mock_remote_service(),
    209                 RegisterOrigin(GURL(kOrigin), _))
    210         .WillOnce(NotifyStateAndCallback(mock_remote_service(),
    211                                          state_to_notify,
    212                                          status_to_return));
    213 
    214     std::vector<SyncServiceState> actual_states;
    215     EXPECT_CALL(event_observer, OnSyncStateUpdated(GURL(), _, _))
    216         .WillRepeatedly(RecordState(&actual_states));
    217 
    218     SyncStatusCode actual_status = SYNC_STATUS_UNKNOWN;
    219     base::RunLoop run_loop;
    220     sync_service_->InitializeForApp(
    221         file_system_->file_system_context(),
    222         GURL(kOrigin),
    223         AssignAndQuitCallback(&run_loop, &actual_status));
    224     run_loop.Run();
    225 
    226     EXPECT_EQ(expected_status, actual_status);
    227     ASSERT_EQ(expected_states.size(), actual_states.size());
    228     for (size_t i = 0; i < actual_states.size(); ++i)
    229       EXPECT_EQ(expected_states[i], actual_states[i]);
    230 
    231     sync_service_->RemoveSyncEventObserver(&event_observer);
    232   }
    233 
    234   FileSystemURL URL(const std::string& path) const {
    235     return file_system_->URL(path);
    236   }
    237 
    238   StrictMock<MockRemoteFileSyncService>* mock_remote_service() {
    239     return remote_service_;
    240   }
    241 
    242   StrictMock<MockLocalChangeProcessor>* mock_local_change_processor() {
    243     return &local_change_processor_;
    244   }
    245 
    246   void EnableSync() {
    247     EXPECT_CALL(*mock_remote_service(), SetSyncEnabled(true)).Times(1);
    248     sync_service_->SetSyncEnabledForTesting(true);
    249   }
    250 
    251   ScopedEnableSyncFSDirectoryOperation enable_directory_operation_;
    252 
    253   content::TestBrowserThreadBundle thread_bundle_;
    254   TestingProfile profile_;
    255   scoped_ptr<CannedSyncableFileSystem> file_system_;
    256 
    257   // Their ownerships are transferred to SyncFileSystemService.
    258   LocalFileSyncService* local_service_;
    259   StrictMock<MockRemoteFileSyncService>* remote_service_;
    260   StrictMock<MockLocalChangeProcessor> local_change_processor_;
    261 
    262   scoped_ptr<SyncFileSystemService> sync_service_;
    263 };
    264 
    265 TEST_F(SyncFileSystemServiceTest, InitializeForApp) {
    266   InitializeApp();
    267 }
    268 
    269 TEST_F(SyncFileSystemServiceTest, InitializeForAppSuccess) {
    270   std::vector<SyncServiceState> expected_states;
    271   expected_states.push_back(SYNC_SERVICE_RUNNING);
    272 
    273   InitializeAppForObserverTest(
    274       REMOTE_SERVICE_OK,
    275       SYNC_STATUS_OK,
    276       expected_states,
    277       SYNC_STATUS_OK);
    278 }
    279 
    280 TEST_F(SyncFileSystemServiceTest, InitializeForAppWithNetworkFailure) {
    281   std::vector<SyncServiceState> expected_states;
    282   expected_states.push_back(SYNC_SERVICE_TEMPORARY_UNAVAILABLE);
    283 
    284   // Notify REMOTE_SERVICE_TEMPORARY_UNAVAILABLE and callback with
    285   // SYNC_STATUS_NETWORK_ERROR.  This should let the
    286   // InitializeApp fail.
    287   InitializeAppForObserverTest(
    288       REMOTE_SERVICE_TEMPORARY_UNAVAILABLE,
    289       SYNC_STATUS_NETWORK_ERROR,
    290       expected_states,
    291       SYNC_STATUS_NETWORK_ERROR);
    292 }
    293 
    294 TEST_F(SyncFileSystemServiceTest, InitializeForAppWithError) {
    295   std::vector<SyncServiceState> expected_states;
    296   expected_states.push_back(SYNC_SERVICE_DISABLED);
    297 
    298   // Notify REMOTE_SERVICE_DISABLED and callback with
    299   // SYNC_STATUS_FAILED.  This should let the InitializeApp fail.
    300   InitializeAppForObserverTest(
    301       REMOTE_SERVICE_DISABLED,
    302       SYNC_STATUS_FAILED,
    303       expected_states,
    304       SYNC_STATUS_FAILED);
    305 }
    306 
    307 TEST_F(SyncFileSystemServiceTest, SimpleLocalSyncFlow) {
    308   InitializeApp();
    309 
    310   StrictMock<MockSyncStatusObserver> status_observer;
    311 
    312   EnableSync();
    313   file_system_->backend()->sync_context()->
    314       set_mock_notify_changes_duration_in_sec(0);
    315   file_system_->AddSyncStatusObserver(&status_observer);
    316 
    317   // We'll test one local sync for this file.
    318   const FileSystemURL kFile(file_system_->URL("foo"));
    319 
    320   base::RunLoop run_loop;
    321 
    322   // We should get called OnSyncEnabled and OnWriteEnabled on kFile as in:
    323   // 1. OnWriteEnabled when PrepareForSync(SYNC_SHARED) is finished and
    324   //    the target file is unlocked for writing
    325   // 2. OnSyncEnabled x 3 times; 1) when CreateFile is finished, 2) when
    326   //    file is unlocked after PrepareForSync, and 3) when the sync is
    327   //    finished.
    328   EXPECT_CALL(status_observer, OnWriteEnabled(kFile))
    329       .Times(AtLeast(1));
    330 
    331   {
    332     ::testing::InSequence sequence;
    333     EXPECT_CALL(status_observer, OnSyncEnabled(kFile))
    334         .Times(AtLeast(2));
    335     EXPECT_CALL(status_observer, OnSyncEnabled(kFile))
    336         .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
    337   }
    338 
    339   // The local_change_processor's ApplyLocalChange should be called once
    340   // with ADD_OR_UPDATE change for TYPE_FILE.
    341   const FileChange change(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
    342                           SYNC_FILE_TYPE_FILE);
    343   EXPECT_CALL(*mock_local_change_processor(),
    344               ApplyLocalChange(change, _, _, kFile, _))
    345       .WillOnce(MockStatusCallback(SYNC_STATUS_OK));
    346 
    347   EXPECT_EQ(base::PLATFORM_FILE_OK, file_system_->CreateFile(kFile));
    348 
    349   run_loop.Run();
    350 
    351   file_system_->RemoveSyncStatusObserver(&status_observer);
    352 }
    353 
    354 TEST_F(SyncFileSystemServiceTest, SimpleRemoteSyncFlow) {
    355   InitializeApp();
    356 
    357   EnableSync();
    358 
    359   base::RunLoop run_loop;
    360 
    361   // We expect a set of method calls for starting a remote sync.
    362   EXPECT_CALL(*mock_remote_service(), ProcessRemoteChange(_))
    363       .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
    364 
    365   // This should trigger a remote sync.
    366   mock_remote_service()->NotifyRemoteChangeQueueUpdated(1);
    367 
    368   run_loop.Run();
    369 }
    370 
    371 TEST_F(SyncFileSystemServiceTest, SimpleSyncFlowWithFileBusy) {
    372   InitializeApp();
    373 
    374   EnableSync();
    375   file_system_->backend()->sync_context()->
    376       set_mock_notify_changes_duration_in_sec(0);
    377 
    378   const FileSystemURL kFile(file_system_->URL("foo"));
    379 
    380   base::RunLoop run_loop;
    381 
    382   {
    383     InSequence sequence;
    384 
    385     // Return with SYNC_STATUS_FILE_BUSY once.
    386     EXPECT_CALL(*mock_remote_service(), ProcessRemoteChange(_))
    387         .WillOnce(MockSyncFileCallback(SYNC_STATUS_FILE_BUSY,
    388                                        kFile));
    389 
    390     // ProcessRemoteChange should be called again when the becomes
    391     // not busy.
    392     EXPECT_CALL(*mock_remote_service(), ProcessRemoteChange(_))
    393         .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
    394   }
    395 
    396   // We might also see an activity for local sync as we're going to make
    397   // a local write operation on kFile.
    398   EXPECT_CALL(*mock_local_change_processor(),
    399               ApplyLocalChange(_, _, _, kFile, _))
    400       .Times(AnyNumber());
    401 
    402   // This should trigger a remote sync.
    403   mock_remote_service()->NotifyRemoteChangeQueueUpdated(1);
    404 
    405   // Start a local operation on the same file (to make it BUSY).
    406   base::RunLoop verify_file_error_run_loop;
    407   BrowserThread::PostTask(
    408       BrowserThread::IO,
    409       FROM_HERE,
    410       base::Bind(&CannedSyncableFileSystem::DoCreateFile,
    411                  base::Unretained(file_system_.get()),
    412                  kFile, base::Bind(&VerifyFileError,
    413                                    &verify_file_error_run_loop)));
    414 
    415   run_loop.Run();
    416 
    417   mock_remote_service()->NotifyRemoteChangeQueueUpdated(0);
    418 
    419   verify_file_error_run_loop.Run();
    420 }
    421 
    422 #if defined(THREAD_SANITIZER)
    423 // SyncFileSystemServiceTest.GetFileSyncStatus fails under ThreadSanitizer,
    424 // see http://crbug.com/294904.
    425 #define MAYBE_GetFileSyncStatus DISABLED_GetFileSyncStatus
    426 #else
    427 #define MAYBE_GetFileSyncStatus GetFileSyncStatus
    428 #endif
    429 TEST_F(SyncFileSystemServiceTest, MAYBE_GetFileSyncStatus) {
    430   InitializeApp();
    431 
    432   const FileSystemURL kFile(file_system_->URL("foo"));
    433 
    434   SyncStatusCode status;
    435   SyncFileStatus sync_file_status;
    436 
    437   // 1. The file is not in conflicting nor in pending change state.
    438   {
    439     base::RunLoop run_loop;
    440     EXPECT_CALL(*mock_remote_service(), IsConflicting(kFile))
    441         .WillOnce(Return(false));
    442 
    443     status = SYNC_STATUS_UNKNOWN;
    444     sync_file_status = SYNC_FILE_STATUS_UNKNOWN;
    445     sync_service_->GetFileSyncStatus(
    446         kFile,
    447         base::Bind(&AssignValueAndQuit<SyncFileStatus>,
    448                    &run_loop, &status, &sync_file_status));
    449     run_loop.Run();
    450 
    451     EXPECT_EQ(SYNC_STATUS_OK, status);
    452     EXPECT_EQ(SYNC_FILE_STATUS_SYNCED, sync_file_status);
    453   }
    454 
    455   // 2. Conflicting case.
    456   {
    457     base::RunLoop run_loop;
    458     EXPECT_CALL(*mock_remote_service(), IsConflicting(kFile))
    459         .WillOnce(Return(true));
    460 
    461     status = SYNC_STATUS_UNKNOWN;
    462     sync_file_status = SYNC_FILE_STATUS_UNKNOWN;
    463     sync_service_->GetFileSyncStatus(
    464         kFile,
    465         base::Bind(&AssignValueAndQuit<SyncFileStatus>,
    466                    &run_loop, &status, &sync_file_status));
    467     run_loop.Run();
    468 
    469     EXPECT_EQ(SYNC_STATUS_OK, status);
    470     EXPECT_EQ(SYNC_FILE_STATUS_CONFLICTING, sync_file_status);
    471   }
    472 
    473   // 3. The file has pending local changes.
    474   {
    475     EXPECT_EQ(base::PLATFORM_FILE_OK, file_system_->CreateFile(kFile));
    476 
    477     base::RunLoop run_loop;
    478     EXPECT_CALL(*mock_remote_service(), IsConflicting(kFile))
    479         .WillOnce(Return(false));
    480 
    481     status = SYNC_STATUS_UNKNOWN;
    482     sync_file_status = SYNC_FILE_STATUS_UNKNOWN;
    483     sync_service_->GetFileSyncStatus(
    484         kFile,
    485         base::Bind(&AssignValueAndQuit<SyncFileStatus>,
    486                    &run_loop, &status, &sync_file_status));
    487     run_loop.Run();
    488 
    489     EXPECT_EQ(SYNC_STATUS_OK, status);
    490     EXPECT_EQ(SYNC_FILE_STATUS_HAS_PENDING_CHANGES, sync_file_status);
    491   }
    492 
    493   // 4. The file has a conflict and pending local changes. In this case
    494   // we return SYNC_FILE_STATUS_CONFLICTING.
    495   {
    496     EXPECT_EQ(base::PLATFORM_FILE_OK, file_system_->TruncateFile(kFile, 1U));
    497 
    498     base::RunLoop run_loop;
    499     EXPECT_CALL(*mock_remote_service(), IsConflicting(kFile))
    500         .WillOnce(Return(true));
    501 
    502     status = SYNC_STATUS_UNKNOWN;
    503     sync_file_status = SYNC_FILE_STATUS_UNKNOWN;
    504     sync_service_->GetFileSyncStatus(
    505         kFile,
    506         base::Bind(&AssignValueAndQuit<SyncFileStatus>,
    507                    &run_loop, &status, &sync_file_status));
    508     run_loop.Run();
    509 
    510     EXPECT_EQ(SYNC_STATUS_OK, status);
    511     EXPECT_EQ(SYNC_FILE_STATUS_CONFLICTING, sync_file_status);
    512   }
    513 }
    514 
    515 }  // namespace sync_file_system
    516