preference_data_type_controller_unittest.cc revision ddb351dbec246cf1fab5ec20d2d5520909041de1 
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