OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/sync/driver/frontend_data_type_controller.h" | 5 #include "components/sync/driver/frontend_data_type_controller.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/bind_helpers.h" | 10 #include "base/bind_helpers.h" |
11 #include "base/callback.h" | 11 #include "base/callback.h" |
12 #include "base/location.h" | 12 #include "base/location.h" |
13 #include "base/message_loop/message_loop.h" | 13 #include "base/message_loop/message_loop.h" |
14 #include "base/run_loop.h" | 14 #include "base/run_loop.h" |
15 #include "base/single_thread_task_runner.h" | 15 #include "base/single_thread_task_runner.h" |
16 #include "base/threading/thread_task_runner_handle.h" | 16 #include "base/threading/thread_task_runner_handle.h" |
17 #include "base/tracked_objects.h" | 17 #include "base/tracked_objects.h" |
18 #include "components/sync/driver/change_processor_mock.h" | 18 #include "components/sync/driver/change_processor_mock.h" |
19 #include "components/sync/driver/data_type_controller_mock.h" | 19 #include "components/sync/driver/data_type_controller_mock.h" |
20 #include "components/sync/driver/fake_sync_client.h" | 20 #include "components/sync/driver/fake_sync_client.h" |
21 #include "components/sync/driver/fake_sync_service.h" | 21 #include "components/sync/driver/fake_sync_service.h" |
22 #include "components/sync/driver/frontend_data_type_controller_mock.h" | 22 #include "components/sync/driver/frontend_data_type_controller_mock.h" |
23 #include "components/sync/driver/model_associator_mock.h" | 23 #include "components/sync/driver/model_associator_mock.h" |
24 #include "components/sync/driver/sync_api_component_factory_mock.h" | 24 #include "components/sync/driver/sync_api_component_factory_mock.h" |
25 #include "testing/gtest/include/gtest/gtest.h" | 25 #include "testing/gtest/include/gtest/gtest.h" |
26 | 26 |
27 using browser_sync::FrontendDataTypeController; | |
28 using browser_sync::FrontendDataTypeControllerMock; | |
29 using sync_driver::ChangeProcessorMock; | |
30 using sync_driver::DataTypeController; | |
31 using sync_driver::ModelAssociatorMock; | |
32 using sync_driver::ModelLoadCallbackMock; | |
33 using sync_driver::StartCallbackMock; | |
34 using testing::_; | 27 using testing::_; |
35 using testing::DoAll; | 28 using testing::DoAll; |
36 using testing::InvokeWithoutArgs; | 29 using testing::InvokeWithoutArgs; |
37 using testing::Return; | 30 using testing::Return; |
38 using testing::SetArgumentPointee; | 31 using testing::SetArgumentPointee; |
39 using testing::StrictMock; | 32 using testing::StrictMock; |
40 | 33 |
41 namespace { | 34 namespace syncer { |
42 | 35 |
43 class FrontendDataTypeControllerFake : public FrontendDataTypeController { | 36 class FrontendDataTypeControllerFake : public FrontendDataTypeController { |
44 public: | 37 public: |
45 FrontendDataTypeControllerFake(sync_driver::SyncClient* sync_client, | 38 FrontendDataTypeControllerFake(SyncClient* sync_client, |
46 FrontendDataTypeControllerMock* mock) | 39 FrontendDataTypeControllerMock* mock) |
47 : FrontendDataTypeController(syncer::BOOKMARKS, | 40 : FrontendDataTypeController(BOOKMARKS, base::Closure(), sync_client), |
48 base::Closure(), | |
49 sync_client), | |
50 mock_(mock), | 41 mock_(mock), |
51 sync_client_(sync_client) {} | 42 sync_client_(sync_client) {} |
52 ~FrontendDataTypeControllerFake() override {} | 43 ~FrontendDataTypeControllerFake() override {} |
53 | 44 |
54 private: | 45 private: |
55 void CreateSyncComponents() override { | 46 void CreateSyncComponents() override { |
56 sync_driver::SyncApiComponentFactory::SyncComponents sync_components = | 47 SyncApiComponentFactory::SyncComponents sync_components = |
57 sync_client_->GetSyncApiComponentFactory() | 48 sync_client_->GetSyncApiComponentFactory() |
58 ->CreateBookmarkSyncComponents(nullptr, CreateErrorHandler()); | 49 ->CreateBookmarkSyncComponents(nullptr, CreateErrorHandler()); |
59 model_associator_.reset(sync_components.model_associator); | 50 model_associator_.reset(sync_components.model_associator); |
60 change_processor_.reset(sync_components.change_processor); | 51 change_processor_.reset(sync_components.change_processor); |
61 } | 52 } |
62 | 53 |
63 // We mock the following methods because their default implementations do | 54 // We mock the following methods because their default implementations do |
64 // nothing, but we still want to make sure they're called appropriately. | 55 // nothing, but we still want to make sure they're called appropriately. |
65 bool StartModels() override { return mock_->StartModels(); } | 56 bool StartModels() override { return mock_->StartModels(); } |
66 void CleanUpState() override { mock_->CleanUpState(); } | 57 void CleanUpState() override { mock_->CleanUpState(); } |
67 void RecordAssociationTime(base::TimeDelta time) override { | 58 void RecordAssociationTime(base::TimeDelta time) override { |
68 mock_->RecordAssociationTime(time); | 59 mock_->RecordAssociationTime(time); |
69 } | 60 } |
70 void RecordStartFailure(DataTypeController::ConfigureResult result) override { | 61 void RecordStartFailure(DataTypeController::ConfigureResult result) override { |
71 mock_->RecordStartFailure(result); | 62 mock_->RecordStartFailure(result); |
72 } | 63 } |
73 | 64 |
74 FrontendDataTypeControllerMock* mock_; | 65 FrontendDataTypeControllerMock* mock_; |
75 sync_driver::SyncClient* sync_client_; | 66 SyncClient* sync_client_; |
76 }; | 67 }; |
77 | 68 |
78 class SyncFrontendDataTypeControllerTest : public testing::Test { | 69 class SyncFrontendDataTypeControllerTest : public testing::Test { |
79 public: | 70 public: |
80 SyncFrontendDataTypeControllerTest() | 71 SyncFrontendDataTypeControllerTest() |
81 : model_associator_(new ModelAssociatorMock()), | 72 : model_associator_(new ModelAssociatorMock()), |
82 change_processor_(new ChangeProcessorMock()), | 73 change_processor_(new ChangeProcessorMock()), |
83 components_factory_(model_associator_, change_processor_), | 74 components_factory_(model_associator_, change_processor_), |
84 sync_client_(&components_factory_) {} | 75 sync_client_(&components_factory_) {} |
85 | 76 |
86 void SetUp() override { | 77 void SetUp() override { |
87 dtc_mock_.reset(new StrictMock<FrontendDataTypeControllerMock>()); | 78 dtc_mock_.reset(new StrictMock<FrontendDataTypeControllerMock>()); |
88 frontend_dtc_.reset( | 79 frontend_dtc_.reset( |
89 new FrontendDataTypeControllerFake(&sync_client_, dtc_mock_.get())); | 80 new FrontendDataTypeControllerFake(&sync_client_, dtc_mock_.get())); |
90 } | 81 } |
91 | 82 |
92 protected: | 83 protected: |
93 void SetStartExpectations() { | 84 void SetStartExpectations() { |
94 EXPECT_CALL(*dtc_mock_.get(), StartModels()).WillOnce(Return(true)); | 85 EXPECT_CALL(*dtc_mock_.get(), StartModels()).WillOnce(Return(true)); |
95 EXPECT_CALL(model_load_callback_, Run(_, _)); | 86 EXPECT_CALL(model_load_callback_, Run(_, _)); |
96 } | 87 } |
97 | 88 |
98 void SetAssociateExpectations() { | 89 void SetAssociateExpectations() { |
99 EXPECT_CALL(*model_associator_, CryptoReadyIfNecessary()) | 90 EXPECT_CALL(*model_associator_, CryptoReadyIfNecessary()) |
100 .WillOnce(Return(true)); | 91 .WillOnce(Return(true)); |
101 EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)) | 92 EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)) |
102 .WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true))); | 93 .WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true))); |
103 EXPECT_CALL(*model_associator_, AssociateModels(_, _)) | 94 EXPECT_CALL(*model_associator_, AssociateModels(_, _)) |
104 .WillOnce(Return(syncer::SyncError())); | 95 .WillOnce(Return(SyncError())); |
105 EXPECT_CALL(*dtc_mock_.get(), RecordAssociationTime(_)); | 96 EXPECT_CALL(*dtc_mock_.get(), RecordAssociationTime(_)); |
106 } | 97 } |
107 | 98 |
108 void SetActivateExpectations(DataTypeController::ConfigureResult result) { | 99 void SetActivateExpectations(DataTypeController::ConfigureResult result) { |
109 EXPECT_CALL(start_callback_, Run(result, _, _)); | 100 EXPECT_CALL(start_callback_, Run(result, _, _)); |
110 } | 101 } |
111 | 102 |
112 void SetStopExpectations() { | 103 void SetStopExpectations() { |
113 EXPECT_CALL(*dtc_mock_.get(), CleanUpState()); | 104 EXPECT_CALL(*dtc_mock_.get(), CleanUpState()); |
114 EXPECT_CALL(*model_associator_, DisassociateModels()) | 105 EXPECT_CALL(*model_associator_, DisassociateModels()) |
115 .WillOnce(Return(syncer::SyncError())); | 106 .WillOnce(Return(SyncError())); |
116 } | 107 } |
117 | 108 |
118 void SetStartFailExpectations(DataTypeController::ConfigureResult result) { | 109 void SetStartFailExpectations(DataTypeController::ConfigureResult result) { |
119 EXPECT_CALL(*dtc_mock_.get(), CleanUpState()); | 110 EXPECT_CALL(*dtc_mock_.get(), CleanUpState()); |
120 EXPECT_CALL(*dtc_mock_.get(), RecordStartFailure(result)); | 111 EXPECT_CALL(*dtc_mock_.get(), RecordStartFailure(result)); |
121 EXPECT_CALL(start_callback_, Run(result, _, _)); | 112 EXPECT_CALL(start_callback_, Run(result, _, _)); |
122 } | 113 } |
123 | 114 |
124 void Start() { | 115 void Start() { |
125 frontend_dtc_->LoadModels(base::Bind( | 116 frontend_dtc_->LoadModels(base::Bind( |
126 &ModelLoadCallbackMock::Run, base::Unretained(&model_load_callback_))); | 117 &ModelLoadCallbackMock::Run, base::Unretained(&model_load_callback_))); |
127 frontend_dtc_->StartAssociating(base::Bind( | 118 frontend_dtc_->StartAssociating(base::Bind( |
128 &StartCallbackMock::Run, base::Unretained(&start_callback_))); | 119 &StartCallbackMock::Run, base::Unretained(&start_callback_))); |
129 PumpLoop(); | 120 PumpLoop(); |
130 } | 121 } |
131 | 122 |
132 void PumpLoop() { base::RunLoop().RunUntilIdle(); } | 123 void PumpLoop() { base::RunLoop().RunUntilIdle(); } |
133 | 124 |
134 base::MessageLoop message_loop_; | 125 base::MessageLoop message_loop_; |
135 ModelAssociatorMock* model_associator_; | 126 ModelAssociatorMock* model_associator_; |
136 ChangeProcessorMock* change_processor_; | 127 ChangeProcessorMock* change_processor_; |
137 SyncApiComponentFactoryMock components_factory_; | 128 SyncApiComponentFactoryMock components_factory_; |
138 sync_driver::FakeSyncClient sync_client_; | 129 FakeSyncClient sync_client_; |
139 std::unique_ptr<FrontendDataTypeControllerFake> frontend_dtc_; | 130 std::unique_ptr<FrontendDataTypeControllerFake> frontend_dtc_; |
140 std::unique_ptr<FrontendDataTypeControllerMock> dtc_mock_; | 131 std::unique_ptr<FrontendDataTypeControllerMock> dtc_mock_; |
141 StartCallbackMock start_callback_; | 132 StartCallbackMock start_callback_; |
142 ModelLoadCallbackMock model_load_callback_; | 133 ModelLoadCallbackMock model_load_callback_; |
143 }; | 134 }; |
144 | 135 |
145 TEST_F(SyncFrontendDataTypeControllerTest, StartOk) { | 136 TEST_F(SyncFrontendDataTypeControllerTest, StartOk) { |
146 SetStartExpectations(); | 137 SetStartExpectations(); |
147 SetAssociateExpectations(); | 138 SetAssociateExpectations(); |
148 SetActivateExpectations(DataTypeController::OK); | 139 SetActivateExpectations(DataTypeController::OK); |
149 EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state()); | 140 EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state()); |
150 Start(); | 141 Start(); |
151 EXPECT_EQ(DataTypeController::RUNNING, frontend_dtc_->state()); | 142 EXPECT_EQ(DataTypeController::RUNNING, frontend_dtc_->state()); |
152 } | 143 } |
153 | 144 |
154 TEST_F(SyncFrontendDataTypeControllerTest, StartFirstRun) { | 145 TEST_F(SyncFrontendDataTypeControllerTest, StartFirstRun) { |
155 SetStartExpectations(); | 146 SetStartExpectations(); |
156 EXPECT_CALL(*model_associator_, CryptoReadyIfNecessary()) | 147 EXPECT_CALL(*model_associator_, CryptoReadyIfNecessary()) |
157 .WillOnce(Return(true)); | 148 .WillOnce(Return(true)); |
158 EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)) | 149 EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)) |
159 .WillOnce(DoAll(SetArgumentPointee<0>(false), Return(true))); | 150 .WillOnce(DoAll(SetArgumentPointee<0>(false), Return(true))); |
160 EXPECT_CALL(*model_associator_, AssociateModels(_, _)) | 151 EXPECT_CALL(*model_associator_, AssociateModels(_, _)) |
161 .WillOnce(Return(syncer::SyncError())); | 152 .WillOnce(Return(SyncError())); |
162 EXPECT_CALL(*dtc_mock_.get(), RecordAssociationTime(_)); | 153 EXPECT_CALL(*dtc_mock_.get(), RecordAssociationTime(_)); |
163 SetActivateExpectations(DataTypeController::OK_FIRST_RUN); | 154 SetActivateExpectations(DataTypeController::OK_FIRST_RUN); |
164 EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state()); | 155 EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state()); |
165 Start(); | 156 Start(); |
166 EXPECT_EQ(DataTypeController::RUNNING, frontend_dtc_->state()); | 157 EXPECT_EQ(DataTypeController::RUNNING, frontend_dtc_->state()); |
167 } | 158 } |
168 | 159 |
169 TEST_F(SyncFrontendDataTypeControllerTest, StartStopBeforeAssociation) { | 160 TEST_F(SyncFrontendDataTypeControllerTest, StartStopBeforeAssociation) { |
170 EXPECT_CALL(*dtc_mock_.get(), StartModels()).WillOnce(Return(true)); | 161 EXPECT_CALL(*dtc_mock_.get(), StartModels()).WillOnce(Return(true)); |
171 EXPECT_CALL(*dtc_mock_.get(), CleanUpState()); | 162 EXPECT_CALL(*dtc_mock_.get(), CleanUpState()); |
(...skipping 17 matching lines...) Expand all Loading... |
189 EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state()); | 180 EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state()); |
190 } | 181 } |
191 | 182 |
192 TEST_F(SyncFrontendDataTypeControllerTest, StartAssociationFailed) { | 183 TEST_F(SyncFrontendDataTypeControllerTest, StartAssociationFailed) { |
193 SetStartExpectations(); | 184 SetStartExpectations(); |
194 EXPECT_CALL(*model_associator_, CryptoReadyIfNecessary()) | 185 EXPECT_CALL(*model_associator_, CryptoReadyIfNecessary()) |
195 .WillOnce(Return(true)); | 186 .WillOnce(Return(true)); |
196 EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)) | 187 EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)) |
197 .WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true))); | 188 .WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true))); |
198 EXPECT_CALL(*model_associator_, AssociateModels(_, _)) | 189 EXPECT_CALL(*model_associator_, AssociateModels(_, _)) |
199 .WillOnce( | 190 .WillOnce(Return( |
200 Return(syncer::SyncError(FROM_HERE, syncer::SyncError::DATATYPE_ERROR, | 191 SyncError(FROM_HERE, SyncError::DATATYPE_ERROR, "error", BOOKMARKS))); |
201 "error", syncer::BOOKMARKS))); | |
202 | 192 |
203 EXPECT_CALL(*dtc_mock_.get(), RecordAssociationTime(_)); | 193 EXPECT_CALL(*dtc_mock_.get(), RecordAssociationTime(_)); |
204 SetStartFailExpectations(DataTypeController::ASSOCIATION_FAILED); | 194 SetStartFailExpectations(DataTypeController::ASSOCIATION_FAILED); |
205 // Set up association to fail with an association failed error. | 195 // Set up association to fail with an association failed error. |
206 EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state()); | 196 EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state()); |
207 Start(); | 197 Start(); |
208 EXPECT_EQ(DataTypeController::DISABLED, frontend_dtc_->state()); | 198 EXPECT_EQ(DataTypeController::DISABLED, frontend_dtc_->state()); |
209 } | 199 } |
210 | 200 |
211 TEST_F(SyncFrontendDataTypeControllerTest, | 201 TEST_F(SyncFrontendDataTypeControllerTest, |
(...skipping 26 matching lines...) Expand all Loading... |
238 SetAssociateExpectations(); | 228 SetAssociateExpectations(); |
239 SetActivateExpectations(DataTypeController::OK); | 229 SetActivateExpectations(DataTypeController::OK); |
240 SetStopExpectations(); | 230 SetStopExpectations(); |
241 EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state()); | 231 EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state()); |
242 Start(); | 232 Start(); |
243 EXPECT_EQ(DataTypeController::RUNNING, frontend_dtc_->state()); | 233 EXPECT_EQ(DataTypeController::RUNNING, frontend_dtc_->state()); |
244 frontend_dtc_->Stop(); | 234 frontend_dtc_->Stop(); |
245 EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state()); | 235 EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state()); |
246 } | 236 } |
247 | 237 |
248 } // namespace | 238 } // namespace syncer |
OLD | NEW |