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 20using browser_sync::PreferenceDataTypeController; 21using browser_sync::ChangeProcessorMock; 22using browser_sync::DataTypeController; 23using browser_sync::ModelAssociatorMock; 24using testing::_; 25using testing::DoAll; 26using testing::InvokeWithoutArgs; 27using testing::Return; 28using testing::SetArgumentPointee; 29 30class StartCallback { 31 public: 32 MOCK_METHOD2(Run, void(DataTypeController::StartResult result, 33 const tracked_objects::Location& location)); 34}; 35 36class 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 87TEST_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 97TEST_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 107TEST_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 118TEST_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 129TEST_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 142TEST_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 157TEST_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