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