Home | History | Annotate | Download | only in glue 
      1 // Copyright (c) 2011 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 "testing/gtest/include/gtest/gtest.h"
      6 
      7 #include "base/callback.h"
      8 #include "base/memory/scoped_ptr.h"
      9 #include "base/message_loop.h"
     10 #include "base/task.h"
     11 #include "base/tracked_objects.h"
     12 #include "chrome/browser/sync/glue/preference_data_type_controller.h"
     13 #include "chrome/browser/sync/glue/change_processor_mock.h"
     14 #include "chrome/browser/sync/glue/model_associator_mock.h"
     15 #include "chrome/browser/sync/profile_sync_factory_mock.h"
     16 #include "chrome/browser/sync/profile_sync_service_mock.h"
     17 #include "chrome/test/profile_mock.h"
     18 #include "content/browser/browser_thread.h"
     19 
     20 using browser_sync::PreferenceDataTypeController;
     21 using browser_sync::ChangeProcessorMock;
     22 using browser_sync::DataTypeController;
     23 using browser_sync::ModelAssociatorMock;
     24 using testing::_;
     25 using testing::DoAll;
     26 using testing::InvokeWithoutArgs;
     27 using testing::Return;
     28 using testing::SetArgumentPointee;
     29 
     30 class StartCallback {
     31  public:
     32   MOCK_METHOD2(Run, void(DataTypeController::StartResult result,
     33                const tracked_objects::Location& location));
     34 };
     35 
     36 class PreferenceDataTypeControllerTest : public testing::Test {
     37  public:
     38   PreferenceDataTypeControllerTest()
     39       : ui_thread_(BrowserThread::UI, &message_loop_) {}
     40 
     41   virtual void SetUp() {
     42     profile_sync_factory_.reset(new ProfileSyncFactoryMock());
     43     preference_dtc_ =
     44         new PreferenceDataTypeController(profile_sync_factory_.get(),
     45                                          &profile_,
     46                                          &service_);
     47   }
     48 
     49  protected:
     50   void SetStartExpectations() {
     51     model_associator_ = new ModelAssociatorMock();
     52     change_processor_ = new ChangeProcessorMock();
     53     EXPECT_CALL(*profile_sync_factory_, CreatePreferenceSyncComponents(_, _)).
     54         WillOnce(Return(ProfileSyncFactory::SyncComponents(model_associator_,
     55                                                            change_processor_)));
     56   }
     57 
     58   void SetAssociateExpectations() {
     59     EXPECT_CALL(*model_associator_, CryptoReadyIfNecessary()).
     60         WillRepeatedly(Return(true));
     61     EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)).
     62         WillRepeatedly(DoAll(SetArgumentPointee<0>(true), Return(true)));
     63     EXPECT_CALL(*model_associator_, AssociateModels()).
     64         WillRepeatedly(Return(true));
     65   }
     66 
     67   void SetActivateExpectations() {
     68     EXPECT_CALL(service_, ActivateDataType(_, _));
     69   }
     70 
     71   void SetStopExpectations() {
     72     EXPECT_CALL(service_, DeactivateDataType(_, _));
     73     EXPECT_CALL(*model_associator_, DisassociateModels());
     74   }
     75 
     76   MessageLoopForUI message_loop_;
     77   BrowserThread ui_thread_;
     78   scoped_refptr<PreferenceDataTypeController> preference_dtc_;
     79   scoped_ptr<ProfileSyncFactoryMock> profile_sync_factory_;
     80   ProfileMock profile_;
     81   ProfileSyncServiceMock service_;
     82   ModelAssociatorMock* model_associator_;
     83   ChangeProcessorMock* change_processor_;
     84   StartCallback start_callback_;
     85 };
     86 
     87 TEST_F(PreferenceDataTypeControllerTest, Start) {
     88   SetStartExpectations();
     89   SetAssociateExpectations();
     90   SetActivateExpectations();
     91   EXPECT_EQ(DataTypeController::NOT_RUNNING, preference_dtc_->state());
     92   EXPECT_CALL(start_callback_, Run(DataTypeController::OK, _));
     93   preference_dtc_->Start(NewCallback(&start_callback_, &StartCallback::Run));
     94   EXPECT_EQ(DataTypeController::RUNNING, preference_dtc_->state());
     95 }
     96 
     97 TEST_F(PreferenceDataTypeControllerTest, StartFirstRun) {
     98   SetStartExpectations();
     99   SetAssociateExpectations();
    100   SetActivateExpectations();
    101   EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)).
    102       WillRepeatedly(DoAll(SetArgumentPointee<0>(false), Return(true)));
    103   EXPECT_CALL(start_callback_, Run(DataTypeController::OK_FIRST_RUN, _));
    104   preference_dtc_->Start(NewCallback(&start_callback_, &StartCallback::Run));
    105 }
    106 
    107 TEST_F(PreferenceDataTypeControllerTest, StartOk) {
    108   SetStartExpectations();
    109   SetAssociateExpectations();
    110   SetActivateExpectations();
    111   EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)).
    112       WillRepeatedly(DoAll(SetArgumentPointee<0>(true), Return(true)));
    113 
    114   EXPECT_CALL(start_callback_, Run(DataTypeController::OK, _));
    115   preference_dtc_->Start(NewCallback(&start_callback_, &StartCallback::Run));
    116 }
    117 
    118 TEST_F(PreferenceDataTypeControllerTest, StartAssociationFailed) {
    119   SetStartExpectations();
    120   SetAssociateExpectations();
    121   EXPECT_CALL(*model_associator_, AssociateModels()).
    122       WillRepeatedly(Return(false));
    123 
    124   EXPECT_CALL(start_callback_, Run(DataTypeController::ASSOCIATION_FAILED, _));
    125   preference_dtc_->Start(NewCallback(&start_callback_, &StartCallback::Run));
    126   EXPECT_EQ(DataTypeController::NOT_RUNNING, preference_dtc_->state());
    127 }
    128 
    129 TEST_F(PreferenceDataTypeControllerTest,
    130        StartAssociationTriggersUnrecoverableError) {
    131   SetStartExpectations();
    132   // Set up association to fail with an unrecoverable error.
    133   EXPECT_CALL(*model_associator_, CryptoReadyIfNecessary()).
    134       WillRepeatedly(Return(true));
    135   EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)).
    136       WillRepeatedly(DoAll(SetArgumentPointee<0>(false), Return(false)));
    137   EXPECT_CALL(start_callback_, Run(DataTypeController::UNRECOVERABLE_ERROR, _));
    138   preference_dtc_->Start(NewCallback(&start_callback_, &StartCallback::Run));
    139   EXPECT_EQ(DataTypeController::NOT_RUNNING, preference_dtc_->state());
    140 }
    141 
    142 TEST_F(PreferenceDataTypeControllerTest, Stop) {
    143   SetStartExpectations();
    144   SetAssociateExpectations();
    145   SetActivateExpectations();
    146   SetStopExpectations();
    147 
    148   EXPECT_EQ(DataTypeController::NOT_RUNNING, preference_dtc_->state());
    149 
    150   EXPECT_CALL(start_callback_, Run(DataTypeController::OK, _));
    151   preference_dtc_->Start(NewCallback(&start_callback_, &StartCallback::Run));
    152   EXPECT_EQ(DataTypeController::RUNNING, preference_dtc_->state());
    153   preference_dtc_->Stop();
    154   EXPECT_EQ(DataTypeController::NOT_RUNNING, preference_dtc_->state());
    155 }
    156 
    157 TEST_F(PreferenceDataTypeControllerTest, OnUnrecoverableError) {
    158   SetStartExpectations();
    159   SetAssociateExpectations();
    160   SetActivateExpectations();
    161   EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)).
    162       WillRepeatedly(DoAll(SetArgumentPointee<0>(true), Return(true)));
    163   EXPECT_CALL(service_, OnUnrecoverableError(_,_)).
    164       WillOnce(InvokeWithoutArgs(preference_dtc_.get(),
    165                                  &PreferenceDataTypeController::Stop));
    166   SetStopExpectations();
    167 
    168   EXPECT_CALL(start_callback_, Run(DataTypeController::OK, _));
    169   preference_dtc_->Start(NewCallback(&start_callback_, &StartCallback::Run));
    170   // This should cause preference_dtc_->Stop() to be called.
    171   preference_dtc_->OnUnrecoverableError(FROM_HERE, "Test");
    172 }
    173