OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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/device_info/device_info_sync_service.h" | 5 #include "components/sync/device_info/device_info_sync_service.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 | 9 |
10 #include <string> | 10 #include <string> |
11 | 11 |
12 #include "base/message_loop/message_loop.h" | 12 #include "base/message_loop/message_loop.h" |
13 #include "components/sync/api/sync_change.h" | 13 #include "components/sync/api/sync_change.h" |
14 #include "components/sync/api/sync_change_processor.h" | 14 #include "components/sync/api/sync_change_processor.h" |
15 #include "components/sync/api/sync_change_processor_wrapper_for_test.h" | 15 #include "components/sync/api/sync_change_processor_wrapper_for_test.h" |
16 #include "components/sync/api/sync_error_factory_mock.h" | 16 #include "components/sync/api/sync_error_factory_mock.h" |
17 #include "components/sync/base/time.h" | 17 #include "components/sync/base/time.h" |
18 #include "components/sync/core/attachments/attachment_service_proxy_for_test.h" | 18 #include "components/sync/core/attachments/attachment_service_proxy_for_test.h" |
19 #include "components/sync/device_info/device_info_util.h" | 19 #include "components/sync/device_info/device_info_util.h" |
20 #include "components/sync/device_info/local_device_info_provider_mock.h" | 20 #include "components/sync/device_info/local_device_info_provider_mock.h" |
21 #include "testing/gtest/include/gtest/gtest.h" | 21 #include "testing/gtest/include/gtest/gtest.h" |
22 | 22 |
23 using base::Time; | 23 using base::Time; |
24 using base::TimeDelta; | 24 using base::TimeDelta; |
| 25 using syncer::AttachmentIdList; |
| 26 using syncer::AttachmentServiceProxyForTest; |
| 27 using syncer::ModelType; |
| 28 using syncer::SyncChange; |
| 29 using syncer::SyncChangeList; |
| 30 using syncer::SyncChangeProcessor; |
| 31 using syncer::SyncChangeProcessorWrapperForTest; |
| 32 using syncer::SyncData; |
| 33 using syncer::SyncDataList; |
| 34 using syncer::SyncError; |
| 35 using syncer::SyncErrorFactory; |
| 36 using syncer::SyncErrorFactoryMock; |
| 37 using syncer::SyncMergeResult; |
25 using sync_pb::EntitySpecifics; | 38 using sync_pb::EntitySpecifics; |
26 | 39 |
27 namespace syncer { | 40 namespace sync_driver { |
28 | 41 |
29 namespace { | 42 namespace { |
30 | 43 |
31 class TestChangeProcessor : public SyncChangeProcessor { | 44 class TestChangeProcessor : public SyncChangeProcessor { |
32 public: | 45 public: |
33 TestChangeProcessor() {} | 46 TestChangeProcessor() {} |
34 ~TestChangeProcessor() override {} | 47 ~TestChangeProcessor() override {} |
35 | 48 |
36 // SyncChangeProcessor implementation. | 49 // SyncChangeProcessor implementation. |
37 // Store a copy of all the changes passed in so we can examine them later. | 50 // Store a copy of all the changes passed in so we can examine them later. |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
116 return entity; | 129 return entity; |
117 } | 130 } |
118 | 131 |
119 // Default |last_updated_timestamp| to now to avoid pulse update on merge. | 132 // Default |last_updated_timestamp| to now to avoid pulse update on merge. |
120 SyncData CreateRemoteData(const std::string& client_id, | 133 SyncData CreateRemoteData(const std::string& client_id, |
121 const std::string& client_name, | 134 const std::string& client_name, |
122 Time last_updated_timestamp = Time::Now()) { | 135 Time last_updated_timestamp = Time::Now()) { |
123 sync_pb::EntitySpecifics entity( | 136 sync_pb::EntitySpecifics entity( |
124 CreateEntitySpecifics(client_id, client_name)); | 137 CreateEntitySpecifics(client_id, client_name)); |
125 entity.mutable_device_info()->set_last_updated_timestamp( | 138 entity.mutable_device_info()->set_last_updated_timestamp( |
126 TimeToProtoTime(last_updated_timestamp)); | 139 syncer::TimeToProtoTime(last_updated_timestamp)); |
127 return SyncData::CreateRemoteData(1, entity, Time(), AttachmentIdList(), | 140 return SyncData::CreateRemoteData(1, entity, Time(), AttachmentIdList(), |
128 AttachmentServiceProxyForTest::Create()); | 141 AttachmentServiceProxyForTest::Create()); |
129 } | 142 } |
130 | 143 |
131 void AddInitialData(SyncDataList* sync_data_list, | 144 void AddInitialData(SyncDataList* sync_data_list, |
132 const std::string& client_id, | 145 const std::string& client_id, |
133 const std::string& client_name) { | 146 const std::string& client_name) { |
134 SyncData sync_data = CreateRemoteData(client_id, client_name); | 147 SyncData sync_data = CreateRemoteData(client_id, client_name); |
135 sync_data_list->push_back(sync_data); | 148 sync_data_list->push_back(sync_data); |
136 } | 149 } |
137 | 150 |
138 void AddChange(SyncChangeList* change_list, | 151 void AddChange(SyncChangeList* change_list, |
139 SyncChange::SyncChangeType change_type, | 152 SyncChange::SyncChangeType change_type, |
140 const std::string& client_id, | 153 const std::string& client_id, |
141 const std::string& client_name) { | 154 const std::string& client_name) { |
142 SyncData sync_data = CreateRemoteData(client_id, client_name); | 155 SyncData sync_data = CreateRemoteData(client_id, client_name); |
143 SyncChange sync_change(FROM_HERE, change_type, sync_data); | 156 SyncChange sync_change(FROM_HERE, change_type, sync_data); |
144 change_list->push_back(sync_change); | 157 change_list->push_back(sync_change); |
145 } | 158 } |
146 | 159 |
147 protected: | 160 protected: |
148 // Private method wrappers through friend class. | 161 // Private method wrappers through friend class. |
149 Time GetLastUpdateTime(const SyncData& data) { | 162 Time GetLastUpdateTime(const syncer::SyncData& data) { |
150 return sync_service_->GetLastUpdateTime(data); | 163 return sync_service_->GetLastUpdateTime(data); |
151 } | 164 } |
152 int CountActiveDevices(const Time now) { | 165 int CountActiveDevices(const Time now) { |
153 return sync_service_->CountActiveDevices(now); | 166 return sync_service_->CountActiveDevices(now); |
154 } | 167 } |
155 void StoreSyncData(const std::string& client_id, const SyncData& sync_data) { | 168 void StoreSyncData(const std::string& client_id, |
| 169 const syncer::SyncData& sync_data) { |
156 sync_service_->StoreSyncData(client_id, sync_data); | 170 sync_service_->StoreSyncData(client_id, sync_data); |
157 } | 171 } |
158 bool IsPulseTimerRunning() { return sync_service_->pulse_timer_.IsRunning(); } | 172 bool IsPulseTimerRunning() { return sync_service_->pulse_timer_.IsRunning(); } |
159 | 173 |
160 // Needs to be created for OneShotTimer to grab the current task runner. | 174 // Needs to be created for OneShotTimer to grab the current task runner. |
161 base::MessageLoop message_loop_; | 175 base::MessageLoop message_loop_; |
162 | 176 |
163 int num_device_info_changed_callbacks_; | 177 int num_device_info_changed_callbacks_; |
164 std::unique_ptr<LocalDeviceInfoProviderMock> local_device_; | 178 std::unique_ptr<LocalDeviceInfoProviderMock> local_device_; |
165 std::unique_ptr<DeviceInfoSyncService> sync_service_; | 179 std::unique_ptr<DeviceInfoSyncService> sync_service_; |
166 std::unique_ptr<TestChangeProcessor> sync_processor_; | 180 std::unique_ptr<TestChangeProcessor> sync_processor_; |
167 }; | 181 }; |
168 | 182 |
169 namespace { | 183 namespace { |
170 | 184 |
171 // Sync with empty initial data. | 185 // Sync with empty initial data. |
172 TEST_F(DeviceInfoSyncServiceTest, StartSyncEmptyInitialData) { | 186 TEST_F(DeviceInfoSyncServiceTest, StartSyncEmptyInitialData) { |
173 EXPECT_FALSE(sync_service_->IsSyncing()); | 187 EXPECT_FALSE(sync_service_->IsSyncing()); |
174 | 188 |
175 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( | 189 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( |
176 DEVICE_INFO, SyncDataList(), PassProcessor(), | 190 syncer::DEVICE_INFO, SyncDataList(), PassProcessor(), |
177 CreateAndPassSyncErrorFactory()); | 191 CreateAndPassSyncErrorFactory()); |
178 | 192 |
179 EXPECT_TRUE(sync_service_->IsSyncing()); | 193 EXPECT_TRUE(sync_service_->IsSyncing()); |
180 EXPECT_EQ(0, merge_result.num_items_added()); | 194 EXPECT_EQ(0, merge_result.num_items_added()); |
181 EXPECT_EQ(0, merge_result.num_items_modified()); | 195 EXPECT_EQ(0, merge_result.num_items_modified()); |
182 EXPECT_EQ(0, merge_result.num_items_deleted()); | 196 EXPECT_EQ(0, merge_result.num_items_deleted()); |
183 EXPECT_EQ(1, merge_result.num_items_before_association()); | 197 EXPECT_EQ(1, merge_result.num_items_before_association()); |
184 EXPECT_EQ(1, merge_result.num_items_after_association()); | 198 EXPECT_EQ(1, merge_result.num_items_after_association()); |
185 EXPECT_EQ(SyncChange::ACTION_ADD, sync_processor_->change_type_at(0)); | 199 EXPECT_EQ(SyncChange::ACTION_ADD, sync_processor_->change_type_at(0)); |
186 | 200 |
187 EXPECT_EQ(1U, sync_processor_->change_list_size()); | 201 EXPECT_EQ(1U, sync_processor_->change_list_size()); |
188 EXPECT_EQ("guid_1", sync_processor_->cache_guid_at(0)); | 202 EXPECT_EQ("guid_1", sync_processor_->cache_guid_at(0)); |
189 | 203 |
190 // Should have one device info corresponding to local device info. | 204 // Should have one device info corresponding to local device info. |
191 EXPECT_EQ(1U, sync_service_->GetAllSyncData(DEVICE_INFO).size()); | 205 EXPECT_EQ(1U, sync_service_->GetAllSyncData(syncer::DEVICE_INFO).size()); |
192 EXPECT_EQ(1U, sync_service_->GetAllDeviceInfo().size()); | 206 EXPECT_EQ(1U, sync_service_->GetAllDeviceInfo().size()); |
193 EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_1")); | 207 EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_1")); |
194 EXPECT_FALSE(sync_service_->GetDeviceInfo("guid_0")); | 208 EXPECT_FALSE(sync_service_->GetDeviceInfo("guid_0")); |
195 } | 209 } |
196 | 210 |
197 TEST_F(DeviceInfoSyncServiceTest, StopSyncing) { | 211 TEST_F(DeviceInfoSyncServiceTest, StopSyncing) { |
198 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( | 212 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( |
199 DEVICE_INFO, SyncDataList(), PassProcessor(), | 213 syncer::DEVICE_INFO, SyncDataList(), PassProcessor(), |
200 CreateAndPassSyncErrorFactory()); | 214 CreateAndPassSyncErrorFactory()); |
201 EXPECT_TRUE(sync_service_->IsSyncing()); | 215 EXPECT_TRUE(sync_service_->IsSyncing()); |
202 EXPECT_EQ(1, num_device_info_changed_callbacks_); | 216 EXPECT_EQ(1, num_device_info_changed_callbacks_); |
203 EXPECT_TRUE(IsPulseTimerRunning()); | 217 EXPECT_TRUE(IsPulseTimerRunning()); |
204 sync_service_->StopSyncing(DEVICE_INFO); | 218 sync_service_->StopSyncing(syncer::DEVICE_INFO); |
205 EXPECT_FALSE(sync_service_->IsSyncing()); | 219 EXPECT_FALSE(sync_service_->IsSyncing()); |
206 EXPECT_EQ(2, num_device_info_changed_callbacks_); | 220 EXPECT_EQ(2, num_device_info_changed_callbacks_); |
207 EXPECT_FALSE(IsPulseTimerRunning()); | 221 EXPECT_FALSE(IsPulseTimerRunning()); |
208 } | 222 } |
209 | 223 |
210 // Sync with initial data matching the local device data. | 224 // Sync with initial data matching the local device data. |
211 TEST_F(DeviceInfoSyncServiceTest, StartSyncMatchingInitialData) { | 225 TEST_F(DeviceInfoSyncServiceTest, StartSyncMatchingInitialData) { |
212 SyncDataList sync_data; | 226 SyncDataList sync_data; |
213 AddInitialData(&sync_data, "guid_1", "client_1"); | 227 AddInitialData(&sync_data, "guid_1", "client_1"); |
214 | 228 |
215 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( | 229 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( |
216 DEVICE_INFO, sync_data, PassProcessor(), CreateAndPassSyncErrorFactory()); | 230 syncer::DEVICE_INFO, sync_data, PassProcessor(), |
| 231 CreateAndPassSyncErrorFactory()); |
217 EXPECT_EQ(0, merge_result.num_items_added()); | 232 EXPECT_EQ(0, merge_result.num_items_added()); |
218 EXPECT_EQ(0, merge_result.num_items_modified()); | 233 EXPECT_EQ(0, merge_result.num_items_modified()); |
219 EXPECT_EQ(0, merge_result.num_items_deleted()); | 234 EXPECT_EQ(0, merge_result.num_items_deleted()); |
220 EXPECT_EQ(1, merge_result.num_items_before_association()); | 235 EXPECT_EQ(1, merge_result.num_items_before_association()); |
221 EXPECT_EQ(1, merge_result.num_items_after_association()); | 236 EXPECT_EQ(1, merge_result.num_items_after_association()); |
222 | 237 |
223 // No changes expected because the device info matches. | 238 // No changes expected because the device info matches. |
224 EXPECT_EQ(0U, sync_processor_->change_list_size()); | 239 EXPECT_EQ(0U, sync_processor_->change_list_size()); |
225 | 240 |
226 EXPECT_EQ(1U, sync_service_->GetAllSyncData(DEVICE_INFO).size()); | 241 EXPECT_EQ(1U, sync_service_->GetAllSyncData(syncer::DEVICE_INFO).size()); |
227 EXPECT_EQ(1U, sync_service_->GetAllDeviceInfo().size()); | 242 EXPECT_EQ(1U, sync_service_->GetAllDeviceInfo().size()); |
228 EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_1")); | 243 EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_1")); |
229 EXPECT_FALSE(sync_service_->GetDeviceInfo("guid_0")); | 244 EXPECT_FALSE(sync_service_->GetDeviceInfo("guid_0")); |
230 } | 245 } |
231 | 246 |
232 // Sync with misc initial data. | 247 // Sync with misc initial data. |
233 TEST_F(DeviceInfoSyncServiceTest, StartSync) { | 248 TEST_F(DeviceInfoSyncServiceTest, StartSync) { |
234 SyncDataList sync_data; | 249 SyncDataList sync_data; |
235 AddInitialData(&sync_data, "guid_2", "foo"); | 250 AddInitialData(&sync_data, "guid_2", "foo"); |
236 AddInitialData(&sync_data, "guid_3", "bar"); | 251 AddInitialData(&sync_data, "guid_3", "bar"); |
237 // This guid matches the local device but the client name is different. | 252 // This guid matches the local device but the client name is different. |
238 AddInitialData(&sync_data, "guid_1", "baz"); | 253 AddInitialData(&sync_data, "guid_1", "baz"); |
239 | 254 |
240 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( | 255 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( |
241 DEVICE_INFO, sync_data, PassProcessor(), CreateAndPassSyncErrorFactory()); | 256 syncer::DEVICE_INFO, sync_data, PassProcessor(), |
| 257 CreateAndPassSyncErrorFactory()); |
242 | 258 |
243 EXPECT_EQ(2, merge_result.num_items_added()); | 259 EXPECT_EQ(2, merge_result.num_items_added()); |
244 EXPECT_EQ(1, merge_result.num_items_modified()); | 260 EXPECT_EQ(1, merge_result.num_items_modified()); |
245 EXPECT_EQ(0, merge_result.num_items_deleted()); | 261 EXPECT_EQ(0, merge_result.num_items_deleted()); |
246 EXPECT_EQ(1, merge_result.num_items_before_association()); | 262 EXPECT_EQ(1, merge_result.num_items_before_association()); |
247 EXPECT_EQ(3, merge_result.num_items_after_association()); | 263 EXPECT_EQ(3, merge_result.num_items_after_association()); |
248 | 264 |
249 EXPECT_EQ(1U, sync_processor_->change_list_size()); | 265 EXPECT_EQ(1U, sync_processor_->change_list_size()); |
250 EXPECT_EQ(SyncChange::ACTION_UPDATE, sync_processor_->change_type_at(0)); | 266 EXPECT_EQ(SyncChange::ACTION_UPDATE, sync_processor_->change_type_at(0)); |
251 EXPECT_EQ("client_1", sync_processor_->client_name_at(0)); | 267 EXPECT_EQ("client_1", sync_processor_->client_name_at(0)); |
252 | 268 |
253 EXPECT_EQ(3U, sync_service_->GetAllSyncData(DEVICE_INFO).size()); | 269 EXPECT_EQ(3U, sync_service_->GetAllSyncData(syncer::DEVICE_INFO).size()); |
254 EXPECT_EQ(3U, sync_service_->GetAllDeviceInfo().size()); | 270 EXPECT_EQ(3U, sync_service_->GetAllDeviceInfo().size()); |
255 EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_1")); | 271 EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_1")); |
256 EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_2")); | 272 EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_2")); |
257 EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_3")); | 273 EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_3")); |
258 EXPECT_FALSE(sync_service_->GetDeviceInfo("guid_0")); | 274 EXPECT_FALSE(sync_service_->GetDeviceInfo("guid_0")); |
259 } | 275 } |
260 | 276 |
261 // Process sync change with ACTION_ADD. | 277 // Process sync change with ACTION_ADD. |
262 // Verify callback. | 278 // Verify callback. |
263 TEST_F(DeviceInfoSyncServiceTest, ProcessAddChange) { | 279 TEST_F(DeviceInfoSyncServiceTest, ProcessAddChange) { |
264 EXPECT_EQ(0, num_device_info_changed_callbacks_); | 280 EXPECT_EQ(0, num_device_info_changed_callbacks_); |
265 | 281 |
266 // Start with an empty initial data. | 282 // Start with an empty initial data. |
267 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( | 283 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( |
268 DEVICE_INFO, SyncDataList(), PassProcessor(), | 284 syncer::DEVICE_INFO, SyncDataList(), PassProcessor(), |
269 CreateAndPassSyncErrorFactory()); | 285 CreateAndPassSyncErrorFactory()); |
270 // There should be only one item corresponding to the local device | 286 // There should be only one item corresponding to the local device |
271 EXPECT_EQ(1, merge_result.num_items_after_association()); | 287 EXPECT_EQ(1, merge_result.num_items_after_association()); |
272 EXPECT_EQ(1, num_device_info_changed_callbacks_); | 288 EXPECT_EQ(1, num_device_info_changed_callbacks_); |
273 | 289 |
274 // Add a new device info with a non-matching guid. | 290 // Add a new device info with a non-matching guid. |
275 SyncChangeList change_list; | 291 SyncChangeList change_list; |
276 AddChange(&change_list, SyncChange::ACTION_ADD, "guid_2", "foo"); | 292 AddChange(&change_list, SyncChange::ACTION_ADD, "guid_2", "foo"); |
277 | 293 |
278 SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list); | 294 SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list); |
279 EXPECT_FALSE(error.IsSet()); | 295 EXPECT_FALSE(error.IsSet()); |
280 EXPECT_EQ(2, num_device_info_changed_callbacks_); | 296 EXPECT_EQ(2, num_device_info_changed_callbacks_); |
281 | 297 |
282 EXPECT_EQ(2U, sync_service_->GetAllDeviceInfo().size()); | 298 EXPECT_EQ(2U, sync_service_->GetAllDeviceInfo().size()); |
283 | 299 |
284 EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_1")); | 300 EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_1")); |
285 EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_2")); | 301 EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_2")); |
286 EXPECT_FALSE(sync_service_->GetDeviceInfo("guid_0")); | 302 EXPECT_FALSE(sync_service_->GetDeviceInfo("guid_0")); |
287 } | 303 } |
288 | 304 |
289 // Process multiple sync change with ACTION_UPDATE and ACTION_ADD. | 305 // Process multiple sync change with ACTION_UPDATE and ACTION_ADD. |
290 // Verify that callback is called multiple times. | 306 // Verify that callback is called multiple times. |
291 TEST_F(DeviceInfoSyncServiceTest, ProcessMultipleChanges) { | 307 TEST_F(DeviceInfoSyncServiceTest, ProcessMultipleChanges) { |
292 SyncDataList sync_data; | 308 SyncDataList sync_data; |
293 AddInitialData(&sync_data, "guid_2", "foo"); | 309 AddInitialData(&sync_data, "guid_2", "foo"); |
294 AddInitialData(&sync_data, "guid_3", "bar"); | 310 AddInitialData(&sync_data, "guid_3", "bar"); |
295 | 311 |
296 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( | 312 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( |
297 DEVICE_INFO, sync_data, PassProcessor(), CreateAndPassSyncErrorFactory()); | 313 syncer::DEVICE_INFO, sync_data, PassProcessor(), |
| 314 CreateAndPassSyncErrorFactory()); |
298 EXPECT_EQ(3, merge_result.num_items_after_association()); | 315 EXPECT_EQ(3, merge_result.num_items_after_association()); |
299 // reset callbacks counter | 316 // reset callbacks counter |
300 num_device_info_changed_callbacks_ = 0; | 317 num_device_info_changed_callbacks_ = 0; |
301 | 318 |
302 SyncChangeList change_list; | 319 SyncChangeList change_list; |
303 AddChange(&change_list, SyncChange::ACTION_UPDATE, "guid_2", "foo_2"); | 320 AddChange(&change_list, SyncChange::ACTION_UPDATE, "guid_2", "foo_2"); |
304 | 321 |
305 SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list); | 322 SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list); |
306 EXPECT_FALSE(error.IsSet()); | 323 EXPECT_FALSE(error.IsSet()); |
307 | 324 |
(...skipping 10 matching lines...) Expand all Loading... |
318 | 335 |
319 EXPECT_EQ(2, num_device_info_changed_callbacks_); | 336 EXPECT_EQ(2, num_device_info_changed_callbacks_); |
320 EXPECT_EQ(4U, sync_service_->GetAllDeviceInfo().size()); | 337 EXPECT_EQ(4U, sync_service_->GetAllDeviceInfo().size()); |
321 EXPECT_EQ("bar_3", sync_service_->GetDeviceInfo("guid_3")->client_name()); | 338 EXPECT_EQ("bar_3", sync_service_->GetDeviceInfo("guid_3")->client_name()); |
322 EXPECT_EQ("baz_4", sync_service_->GetDeviceInfo("guid_4")->client_name()); | 339 EXPECT_EQ("baz_4", sync_service_->GetDeviceInfo("guid_4")->client_name()); |
323 } | 340 } |
324 | 341 |
325 // Process update to the local device info and verify that it is ignored. | 342 // Process update to the local device info and verify that it is ignored. |
326 TEST_F(DeviceInfoSyncServiceTest, ProcessUpdateChangeMatchingLocalDevice) { | 343 TEST_F(DeviceInfoSyncServiceTest, ProcessUpdateChangeMatchingLocalDevice) { |
327 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( | 344 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( |
328 DEVICE_INFO, SyncDataList(), PassProcessor(), | 345 syncer::DEVICE_INFO, SyncDataList(), PassProcessor(), |
329 CreateAndPassSyncErrorFactory()); | 346 CreateAndPassSyncErrorFactory()); |
330 EXPECT_EQ(1, merge_result.num_items_after_association()); | 347 EXPECT_EQ(1, merge_result.num_items_after_association()); |
331 // reset callbacks counter | 348 // reset callbacks counter |
332 num_device_info_changed_callbacks_ = 0; | 349 num_device_info_changed_callbacks_ = 0; |
333 | 350 |
334 SyncChangeList change_list; | 351 SyncChangeList change_list; |
335 AddChange(&change_list, SyncChange::ACTION_UPDATE, "guid_1", "foo_1"); | 352 AddChange(&change_list, SyncChange::ACTION_UPDATE, "guid_1", "foo_1"); |
336 | 353 |
337 SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list); | 354 SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list); |
338 EXPECT_FALSE(error.IsSet()); | 355 EXPECT_FALSE(error.IsSet()); |
339 // Callback shouldn't be sent in this case. | 356 // Callback shouldn't be sent in this case. |
340 EXPECT_EQ(0, num_device_info_changed_callbacks_); | 357 EXPECT_EQ(0, num_device_info_changed_callbacks_); |
341 // Should still have the old local device Info. | 358 // Should still have the old local device Info. |
342 EXPECT_EQ(1U, sync_service_->GetAllDeviceInfo().size()); | 359 EXPECT_EQ(1U, sync_service_->GetAllDeviceInfo().size()); |
343 EXPECT_EQ("client_1", sync_service_->GetDeviceInfo("guid_1")->client_name()); | 360 EXPECT_EQ("client_1", sync_service_->GetDeviceInfo("guid_1")->client_name()); |
344 } | 361 } |
345 | 362 |
346 // Process sync change with ACTION_DELETE. | 363 // Process sync change with ACTION_DELETE. |
347 TEST_F(DeviceInfoSyncServiceTest, ProcessDeleteChange) { | 364 TEST_F(DeviceInfoSyncServiceTest, ProcessDeleteChange) { |
348 SyncDataList sync_data; | 365 SyncDataList sync_data; |
349 AddInitialData(&sync_data, "guid_2", "foo"); | 366 AddInitialData(&sync_data, "guid_2", "foo"); |
350 AddInitialData(&sync_data, "guid_3", "bar"); | 367 AddInitialData(&sync_data, "guid_3", "bar"); |
351 | 368 |
352 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( | 369 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( |
353 DEVICE_INFO, sync_data, PassProcessor(), CreateAndPassSyncErrorFactory()); | 370 syncer::DEVICE_INFO, sync_data, PassProcessor(), |
| 371 CreateAndPassSyncErrorFactory()); |
354 EXPECT_EQ(3, merge_result.num_items_after_association()); | 372 EXPECT_EQ(3, merge_result.num_items_after_association()); |
355 // reset callbacks counter | 373 // reset callbacks counter |
356 num_device_info_changed_callbacks_ = 0; | 374 num_device_info_changed_callbacks_ = 0; |
357 | 375 |
358 SyncChangeList change_list; | 376 SyncChangeList change_list; |
359 AddChange(&change_list, SyncChange::ACTION_DELETE, "guid_2", "foo_2"); | 377 AddChange(&change_list, SyncChange::ACTION_DELETE, "guid_2", "foo_2"); |
360 | 378 |
361 SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list); | 379 SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list); |
362 EXPECT_FALSE(error.IsSet()); | 380 EXPECT_FALSE(error.IsSet()); |
363 | 381 |
364 EXPECT_EQ(1, num_device_info_changed_callbacks_); | 382 EXPECT_EQ(1, num_device_info_changed_callbacks_); |
365 EXPECT_EQ(2U, sync_service_->GetAllDeviceInfo().size()); | 383 EXPECT_EQ(2U, sync_service_->GetAllDeviceInfo().size()); |
366 EXPECT_FALSE(sync_service_->GetDeviceInfo("guid_2")); | 384 EXPECT_FALSE(sync_service_->GetDeviceInfo("guid_2")); |
367 } | 385 } |
368 | 386 |
369 // Process sync change with unexpected action. | 387 // Process sync change with unexpected action. |
370 TEST_F(DeviceInfoSyncServiceTest, ProcessInvalidChange) { | 388 TEST_F(DeviceInfoSyncServiceTest, ProcessInvalidChange) { |
371 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( | 389 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( |
372 DEVICE_INFO, SyncDataList(), PassProcessor(), | 390 syncer::DEVICE_INFO, SyncDataList(), PassProcessor(), |
373 CreateAndPassSyncErrorFactory()); | 391 CreateAndPassSyncErrorFactory()); |
374 EXPECT_EQ(1, merge_result.num_items_after_association()); | 392 EXPECT_EQ(1, merge_result.num_items_after_association()); |
375 // reset callbacks counter | 393 // reset callbacks counter |
376 num_device_info_changed_callbacks_ = 0; | 394 num_device_info_changed_callbacks_ = 0; |
377 | 395 |
378 SyncChangeList change_list; | 396 SyncChangeList change_list; |
379 AddChange(&change_list, (SyncChange::SyncChangeType)100, "guid_2", "foo_2"); | 397 AddChange(&change_list, (SyncChange::SyncChangeType)100, "guid_2", "foo_2"); |
380 | 398 |
381 SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list); | 399 SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list); |
382 EXPECT_TRUE(error.IsSet()); | 400 EXPECT_TRUE(error.IsSet()); |
383 | 401 |
384 // The number of callback should still be zero. | 402 // The number of callback should still be zero. |
385 EXPECT_EQ(0, num_device_info_changed_callbacks_); | 403 EXPECT_EQ(0, num_device_info_changed_callbacks_); |
386 EXPECT_EQ(1U, sync_service_->GetAllDeviceInfo().size()); | 404 EXPECT_EQ(1U, sync_service_->GetAllDeviceInfo().size()); |
387 } | 405 } |
388 | 406 |
389 // Process sync change after unsubscribing from notifications. | 407 // Process sync change after unsubscribing from notifications. |
390 TEST_F(DeviceInfoSyncServiceTest, ProcessChangesAfterUnsubscribing) { | 408 TEST_F(DeviceInfoSyncServiceTest, ProcessChangesAfterUnsubscribing) { |
391 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( | 409 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( |
392 DEVICE_INFO, SyncDataList(), PassProcessor(), | 410 syncer::DEVICE_INFO, SyncDataList(), PassProcessor(), |
393 CreateAndPassSyncErrorFactory()); | 411 CreateAndPassSyncErrorFactory()); |
394 EXPECT_EQ(1, merge_result.num_items_after_association()); | 412 EXPECT_EQ(1, merge_result.num_items_after_association()); |
395 // reset callbacks counter | 413 // reset callbacks counter |
396 num_device_info_changed_callbacks_ = 0; | 414 num_device_info_changed_callbacks_ = 0; |
397 | 415 |
398 SyncChangeList change_list; | 416 SyncChangeList change_list; |
399 AddChange(&change_list, SyncChange::ACTION_ADD, "guid_2", "foo_2"); | 417 AddChange(&change_list, SyncChange::ACTION_ADD, "guid_2", "foo_2"); |
400 | 418 |
401 // Unsubscribe observer before processing changes. | 419 // Unsubscribe observer before processing changes. |
402 sync_service_->RemoveObserver(this); | 420 sync_service_->RemoveObserver(this); |
403 | 421 |
404 SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list); | 422 SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list); |
405 EXPECT_FALSE(error.IsSet()); | 423 EXPECT_FALSE(error.IsSet()); |
406 | 424 |
407 // The number of callback should still be zero. | 425 // The number of callback should still be zero. |
408 EXPECT_EQ(0, num_device_info_changed_callbacks_); | 426 EXPECT_EQ(0, num_device_info_changed_callbacks_); |
409 } | 427 } |
410 | 428 |
411 // While the initial data will match the current device, the last modified time | 429 // While the initial data will match the current device, the last modified time |
412 // should be greater than the threshold and cause an update anyways. | 430 // should be greater than the threshold and cause an update anyways. |
413 TEST_F(DeviceInfoSyncServiceTest, StartSyncMatchingButStale) { | 431 TEST_F(DeviceInfoSyncServiceTest, StartSyncMatchingButStale) { |
414 SyncDataList sync_data; | 432 SyncDataList sync_data; |
415 sync_data.push_back(CreateRemoteData("guid_1", "foo_1", Time())); | 433 sync_data.push_back(CreateRemoteData("guid_1", "foo_1", Time())); |
416 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( | 434 SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing( |
417 DEVICE_INFO, sync_data, PassProcessor(), CreateAndPassSyncErrorFactory()); | 435 syncer::DEVICE_INFO, sync_data, PassProcessor(), |
| 436 CreateAndPassSyncErrorFactory()); |
418 | 437 |
419 EXPECT_EQ(1U, sync_processor_->change_list_size()); | 438 EXPECT_EQ(1U, sync_processor_->change_list_size()); |
420 EXPECT_EQ(SyncChange::ACTION_UPDATE, sync_processor_->change_type_at(0)); | 439 EXPECT_EQ(SyncChange::ACTION_UPDATE, sync_processor_->change_type_at(0)); |
421 EXPECT_EQ("guid_1", sync_processor_->cache_guid_at(0)); | 440 EXPECT_EQ("guid_1", sync_processor_->cache_guid_at(0)); |
422 EXPECT_EQ("client_1", sync_processor_->client_name_at(0)); | 441 EXPECT_EQ("client_1", sync_processor_->client_name_at(0)); |
423 } | 442 } |
424 | 443 |
425 TEST_F(DeviceInfoSyncServiceTest, GetLastUpdateTime) { | 444 TEST_F(DeviceInfoSyncServiceTest, GetLastUpdateTime) { |
426 Time time1(Time() + TimeDelta::FromDays(1)); | 445 Time time1(Time() + TimeDelta::FromDays(1)); |
427 Time time2(Time() + TimeDelta::FromDays(2)); | 446 Time time2(Time() + TimeDelta::FromDays(2)); |
428 | 447 |
429 SyncData localA( | 448 SyncData localA( |
430 SyncData::CreateLocalData("a", "a", CreateEntitySpecifics("a", "a"))); | 449 SyncData::CreateLocalData("a", "a", CreateEntitySpecifics("a", "a"))); |
431 | 450 |
432 EntitySpecifics entityB(CreateEntitySpecifics("b", "b")); | 451 EntitySpecifics entityB(CreateEntitySpecifics("b", "b")); |
433 entityB.mutable_device_info()->set_last_updated_timestamp( | 452 entityB.mutable_device_info()->set_last_updated_timestamp( |
434 TimeToProtoTime(time1)); | 453 syncer::TimeToProtoTime(time1)); |
435 SyncData localB(SyncData::CreateLocalData("b", "b", entityB)); | 454 SyncData localB(SyncData::CreateLocalData("b", "b", entityB)); |
436 | 455 |
437 SyncData remoteC(SyncData::CreateRemoteData( | 456 SyncData remoteC(SyncData::CreateRemoteData( |
438 1, CreateEntitySpecifics("c", "c"), time2, AttachmentIdList(), | 457 1, CreateEntitySpecifics("c", "c"), time2, AttachmentIdList(), |
439 AttachmentServiceProxyForTest::Create())); | 458 AttachmentServiceProxyForTest::Create())); |
440 | 459 |
441 EntitySpecifics entityD(CreateEntitySpecifics("d", "d")); | 460 EntitySpecifics entityD(CreateEntitySpecifics("d", "d")); |
442 entityD.mutable_device_info()->set_last_updated_timestamp( | 461 entityD.mutable_device_info()->set_last_updated_timestamp( |
443 TimeToProtoTime(time1)); | 462 syncer::TimeToProtoTime(time1)); |
444 SyncData remoteD( | 463 SyncData remoteD( |
445 SyncData::CreateRemoteData(1, entityD, time2, AttachmentIdList(), | 464 SyncData::CreateRemoteData(1, entityD, time2, AttachmentIdList(), |
446 AttachmentServiceProxyForTest::Create())); | 465 AttachmentServiceProxyForTest::Create())); |
447 | 466 |
448 EXPECT_EQ(Time(), GetLastUpdateTime(localA)); | 467 EXPECT_EQ(Time(), GetLastUpdateTime(localA)); |
449 EXPECT_EQ(time1, GetLastUpdateTime(localB)); | 468 EXPECT_EQ(time1, GetLastUpdateTime(localB)); |
450 EXPECT_EQ(time2, GetLastUpdateTime(remoteC)); | 469 EXPECT_EQ(time2, GetLastUpdateTime(remoteC)); |
451 EXPECT_EQ(time1, GetLastUpdateTime(remoteD)); | 470 EXPECT_EQ(time1, GetLastUpdateTime(remoteD)); |
452 } | 471 } |
453 | 472 |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
552 TEST_F(DeviceInfoSyncServiceTest, CountActiveDevicesLocalStale) { | 571 TEST_F(DeviceInfoSyncServiceTest, CountActiveDevicesLocalStale) { |
553 sync_pb::EntitySpecifics entity; | 572 sync_pb::EntitySpecifics entity; |
554 sync_pb::DeviceInfoSpecifics& specifics = *entity.mutable_device_info(); | 573 sync_pb::DeviceInfoSpecifics& specifics = *entity.mutable_device_info(); |
555 specifics.set_cache_guid("stale"); | 574 specifics.set_cache_guid("stale"); |
556 StoreSyncData("stale", SyncData::CreateLocalData("stale", "stale", entity)); | 575 StoreSyncData("stale", SyncData::CreateLocalData("stale", "stale", entity)); |
557 EXPECT_EQ(0, CountActiveDevices(Time() + DeviceInfoUtil::kActiveThreshold)); | 576 EXPECT_EQ(0, CountActiveDevices(Time() + DeviceInfoUtil::kActiveThreshold)); |
558 } | 577 } |
559 | 578 |
560 } // namespace | 579 } // namespace |
561 | 580 |
562 } // namespace syncer | 581 } // namespace sync_driver |
OLD | NEW |