| OLD | NEW |
|---|
| (Empty) |
| 1 #!/usr/bin/env python | |
| 2 # Copyright 2013 The Chromium Authors. All rights reserved. | |
| 3 # Use of this source code is governed by a BSD-style license that can be | |
| 4 # found in the LICENSE file. | |
| 5 | |
| 6 """Tests exercising chromiumsync and SyncDataModel.""" | |
| 7 | |
| 8 import pickle | |
| 9 import unittest | |
| 10 | |
| 11 import autofill_specifics_pb2 | |
| 12 import bookmark_specifics_pb2 | |
| 13 import chromiumsync | |
| 14 import managed_user_specifics_pb2 | |
| 15 import sync_pb2 | |
| 16 import theme_specifics_pb2 | |
| 17 | |
| 18 class SyncDataModelTest(unittest.TestCase): | |
| 19 def setUp(self): | |
| 20 self.model = chromiumsync.SyncDataModel() | |
| 21 # The Synced Bookmarks folder is not created by default | |
| 22 self._expect_synced_bookmarks_folder = False | |
| 23 | |
| 24 def AddToModel(self, proto): | |
| 25 self.model._entries[proto.id_string] = proto | |
| 26 | |
| 27 def GetChangesFromTimestamp(self, requested_types, timestamp): | |
| 28 message = sync_pb2.GetUpdatesMessage() | |
| 29 message.from_timestamp = timestamp | |
| 30 for data_type in requested_types: | |
| 31 getattr(message.requested_types, | |
| 32 chromiumsync.SYNC_TYPE_TO_DESCRIPTOR[ | |
| 33 data_type].name).SetInParent() | |
| 34 return self.model.GetChanges( | |
| 35 chromiumsync.UpdateSieve(message, self.model.migration_history)) | |
| 36 | |
| 37 def FindMarkerByNumber(self, markers, datatype): | |
| 38 """Search a list of progress markers and find the one for a datatype.""" | |
| 39 for marker in markers: | |
| 40 if marker.data_type_id == datatype.number: | |
| 41 return marker | |
| 42 self.fail('Required marker not found: %s' % datatype.name) | |
| 43 | |
| 44 def testPermanentItemSpecs(self): | |
| 45 specs = chromiumsync.SyncDataModel._PERMANENT_ITEM_SPECS | |
| 46 | |
| 47 declared_specs = set(['0']) | |
| 48 for spec in specs: | |
| 49 self.assertTrue(spec.parent_tag in declared_specs, 'parent tags must ' | |
| 50 'be declared before use') | |
| 51 declared_specs.add(spec.tag) | |
| 52 | |
| 53 unique_datatypes = set([x.sync_type for x in specs]) | |
| 54 self.assertEqual(unique_datatypes, | |
| 55 set(chromiumsync.ALL_TYPES[1:]), | |
| 56 'Every sync datatype should have a permanent folder ' | |
| 57 'associated with it') | |
| 58 | |
| 59 def testSaveEntry(self): | |
| 60 proto = sync_pb2.SyncEntity() | |
| 61 proto.id_string = 'abcd' | |
| 62 proto.version = 0 | |
| 63 self.assertFalse(self.model._ItemExists(proto.id_string)) | |
| 64 self.model._SaveEntry(proto) | |
| 65 self.assertEqual(1, proto.version) | |
| 66 self.assertTrue(self.model._ItemExists(proto.id_string)) | |
| 67 self.model._SaveEntry(proto) | |
| 68 self.assertEqual(2, proto.version) | |
| 69 proto.version = 0 | |
| 70 self.assertTrue(self.model._ItemExists(proto.id_string)) | |
| 71 self.assertEqual(2, self.model._entries[proto.id_string].version) | |
| 72 | |
| 73 def testCreatePermanentItems(self): | |
| 74 self.model._CreateDefaultPermanentItems(chromiumsync.ALL_TYPES) | |
| 75 self.assertEqual(len(chromiumsync.ALL_TYPES) + 1, | |
| 76 len(self.model._entries)) | |
| 77 | |
| 78 def ExpectedPermanentItemCount(self, sync_type): | |
| 79 if sync_type == chromiumsync.BOOKMARK: | |
| 80 if self._expect_synced_bookmarks_folder: | |
| 81 return 4 | |
| 82 else: | |
| 83 return 3 | |
| 84 else: | |
| 85 return 1 | |
| 86 | |
| 87 def testGetChangesFromTimestampZeroForEachType(self): | |
| 88 all_types = chromiumsync.ALL_TYPES[1:] | |
| 89 for sync_type in all_types: | |
| 90 self.model = chromiumsync.SyncDataModel() | |
| 91 request_types = [sync_type] | |
| 92 | |
| 93 version, changes, remaining = ( | |
| 94 self.GetChangesFromTimestamp(request_types, 0)) | |
| 95 | |
| 96 expected_count = self.ExpectedPermanentItemCount(sync_type) | |
| 97 self.assertEqual(expected_count, version) | |
| 98 self.assertEqual(expected_count, len(changes)) | |
| 99 for change in changes: | |
| 100 self.assertTrue(change.HasField('server_defined_unique_tag')) | |
| 101 self.assertEqual(change.version, change.sync_timestamp) | |
| 102 self.assertTrue(change.version <= version) | |
| 103 | |
| 104 # Test idempotence: another GetUpdates from ts=0 shouldn't recreate. | |
| 105 version, changes, remaining = ( | |
| 106 self.GetChangesFromTimestamp(request_types, 0)) | |
| 107 self.assertEqual(expected_count, version) | |
| 108 self.assertEqual(expected_count, len(changes)) | |
| 109 self.assertEqual(0, remaining) | |
| 110 | |
| 111 # Doing a wider GetUpdates from timestamp zero shouldn't recreate either. | |
| 112 new_version, changes, remaining = ( | |
| 113 self.GetChangesFromTimestamp(all_types, 0)) | |
| 114 if self._expect_synced_bookmarks_folder: | |
| 115 self.assertEqual(len(chromiumsync.SyncDataModel._PERMANENT_ITEM_SPECS), | |
| 116 new_version) | |
| 117 else: | |
| 118 self.assertEqual( | |
| 119 len(chromiumsync.SyncDataModel._PERMANENT_ITEM_SPECS) -1, | |
| 120 new_version) | |
| 121 self.assertEqual(new_version, len(changes)) | |
| 122 self.assertEqual(0, remaining) | |
| 123 version, changes, remaining = ( | |
| 124 self.GetChangesFromTimestamp(request_types, 0)) | |
| 125 self.assertEqual(new_version, version) | |
| 126 self.assertEqual(expected_count, len(changes)) | |
| 127 self.assertEqual(0, remaining) | |
| 128 | |
| 129 def testBatchSize(self): | |
| 130 for sync_type in chromiumsync.ALL_TYPES[1:]: | |
| 131 specifics = chromiumsync.GetDefaultEntitySpecifics(sync_type) | |
| 132 self.model = chromiumsync.SyncDataModel() | |
| 133 request_types = [sync_type] | |
| 134 | |
| 135 for i in range(self.model._BATCH_SIZE*3): | |
| 136 entry = sync_pb2.SyncEntity() | |
| 137 entry.id_string = 'batch test %d' % i | |
| 138 entry.specifics.CopyFrom(specifics) | |
| 139 self.model._SaveEntry(entry) | |
| 140 last_bit = self.ExpectedPermanentItemCount(sync_type) | |
| 141 version, changes, changes_remaining = ( | |
| 142 self.GetChangesFromTimestamp(request_types, 0)) | |
| 143 self.assertEqual(self.model._BATCH_SIZE, version) | |
| 144 self.assertEqual(self.model._BATCH_SIZE*2 + last_bit, changes_remaining) | |
| 145 version, changes, changes_remaining = ( | |
| 146 self.GetChangesFromTimestamp(request_types, version)) | |
| 147 self.assertEqual(self.model._BATCH_SIZE*2, version) | |
| 148 self.assertEqual(self.model._BATCH_SIZE + last_bit, changes_remaining) | |
| 149 version, changes, changes_remaining = ( | |
| 150 self.GetChangesFromTimestamp(request_types, version)) | |
| 151 self.assertEqual(self.model._BATCH_SIZE*3, version) | |
| 152 self.assertEqual(last_bit, changes_remaining) | |
| 153 version, changes, changes_remaining = ( | |
| 154 self.GetChangesFromTimestamp(request_types, version)) | |
| 155 self.assertEqual(self.model._BATCH_SIZE*3 + last_bit, version) | |
| 156 self.assertEqual(0, changes_remaining) | |
| 157 | |
| 158 # Now delete a third of the items. | |
| 159 for i in xrange(self.model._BATCH_SIZE*3 - 1, 0, -3): | |
| 160 entry = sync_pb2.SyncEntity() | |
| 161 entry.id_string = 'batch test %d' % i | |
| 162 entry.deleted = True | |
| 163 self.model._SaveEntry(entry) | |
| 164 | |
| 165 # The batch counts shouldn't change. | |
| 166 version, changes, changes_remaining = ( | |
| 167 self.GetChangesFromTimestamp(request_types, 0)) | |
| 168 self.assertEqual(self.model._BATCH_SIZE, len(changes)) | |
| 169 self.assertEqual(self.model._BATCH_SIZE*2 + last_bit, changes_remaining) | |
| 170 version, changes, changes_remaining = ( | |
| 171 self.GetChangesFromTimestamp(request_types, version)) | |
| 172 self.assertEqual(self.model._BATCH_SIZE, len(changes)) | |
| 173 self.assertEqual(self.model._BATCH_SIZE + last_bit, changes_remaining) | |
| 174 version, changes, changes_remaining = ( | |
| 175 self.GetChangesFromTimestamp(request_types, version)) | |
| 176 self.assertEqual(self.model._BATCH_SIZE, len(changes)) | |
| 177 self.assertEqual(last_bit, changes_remaining) | |
| 178 version, changes, changes_remaining = ( | |
| 179 self.GetChangesFromTimestamp(request_types, version)) | |
| 180 self.assertEqual(last_bit, len(changes)) | |
| 181 self.assertEqual(self.model._BATCH_SIZE*4 + last_bit, version) | |
| 182 self.assertEqual(0, changes_remaining) | |
| 183 | |
| 184 def testCommitEachDataType(self): | |
| 185 for sync_type in chromiumsync.ALL_TYPES[1:]: | |
| 186 specifics = chromiumsync.GetDefaultEntitySpecifics(sync_type) | |
| 187 self.model = chromiumsync.SyncDataModel() | |
| 188 my_cache_guid = '112358132134' | |
| 189 parent = 'foobar' | |
| 190 commit_session = {} | |
| 191 | |
| 192 # Start with a GetUpdates from timestamp 0, to populate permanent items. | |
| 193 original_version, original_changes, changes_remaining = ( | |
| 194 self.GetChangesFromTimestamp([sync_type], 0)) | |
| 195 | |
| 196 def DoCommit(original=None, id_string='', name=None, parent=None, | |
| 197 position=0): | |
| 198 proto = sync_pb2.SyncEntity() | |
| 199 if original is not None: | |
| 200 proto.version = original.version | |
| 201 proto.id_string = original.id_string | |
| 202 proto.parent_id_string = original.parent_id_string | |
| 203 proto.name = original.name | |
| 204 else: | |
| 205 proto.id_string = id_string | |
| 206 proto.version = 0 | |
| 207 proto.specifics.CopyFrom(specifics) | |
| 208 if name is not None: | |
| 209 proto.name = name | |
| 210 if parent: | |
| 211 proto.parent_id_string = parent.id_string | |
| 212 proto.insert_after_item_id = 'please discard' | |
| 213 proto.position_in_parent = position | |
| 214 proto.folder = True | |
| 215 proto.deleted = False | |
| 216 result = self.model.CommitEntry(proto, my_cache_guid, commit_session) | |
| 217 self.assertTrue(result) | |
| 218 return (proto, result) | |
| 219 | |
| 220 # Commit a new item. | |
| 221 proto1, result1 = DoCommit(name='namae', id_string='Foo', | |
| 222 parent=original_changes[-1], position=100) | |
| 223 # Commit an item whose parent is another item (referenced via the | |
| 224 # pre-commit ID). | |
| 225 proto2, result2 = DoCommit(name='Secondo', id_string='Bar', | |
| 226 parent=proto1, position=-100) | |
| 227 # Commit a sibling of the second item. | |
| 228 proto3, result3 = DoCommit(name='Third!', id_string='Baz', | |
| 229 parent=proto1, position=-50) | |
| 230 | |
| 231 self.assertEqual(3, len(commit_session)) | |
| 232 for p, r in [(proto1, result1), (proto2, result2), (proto3, result3)]: | |
| 233 self.assertNotEqual(r.id_string, p.id_string) | |
| 234 self.assertEqual(r.originator_client_item_id, p.id_string) | |
| 235 self.assertEqual(r.originator_cache_guid, my_cache_guid) | |
| 236 self.assertTrue(r is not self.model._entries[r.id_string], | |
| 237 "Commit result didn't make a defensive copy.") | |
| 238 self.assertTrue(p is not self.model._entries[r.id_string], | |
| 239 "Commit result didn't make a defensive copy.") | |
| 240 self.assertEqual(commit_session.get(p.id_string), r.id_string) | |
| 241 self.assertTrue(r.version > original_version) | |
| 242 self.assertEqual(result1.parent_id_string, proto1.parent_id_string) | |
| 243 self.assertEqual(result2.parent_id_string, result1.id_string) | |
| 244 version, changes, remaining = ( | |
| 245 self.GetChangesFromTimestamp([sync_type], original_version)) | |
| 246 self.assertEqual(3, len(changes)) | |
| 247 self.assertEqual(0, remaining) | |
| 248 self.assertEqual(original_version + 3, version) | |
| 249 self.assertEqual([result1, result2, result3], changes) | |
| 250 for c in changes: | |
| 251 self.assertTrue(c is not self.model._entries[c.id_string], | |
| 252 "GetChanges didn't make a defensive copy.") | |
| 253 self.assertTrue(result2.position_in_parent < result3.position_in_parent) | |
| 254 self.assertEqual(-100, result2.position_in_parent) | |
| 255 | |
| 256 # Now update the items so that the second item is the parent of the | |
| 257 # first; with the first sandwiched between two new items (4 and 5). | |
| 258 # Do this in a new commit session, meaning we'll reference items from | |
| 259 # the first batch by their post-commit, server IDs. | |
| 260 commit_session = {} | |
| 261 old_cache_guid = my_cache_guid | |
| 262 my_cache_guid = 'A different GUID' | |
| 263 proto2b, result2b = DoCommit(original=result2, | |
| 264 parent=original_changes[-1]) | |
| 265 proto4, result4 = DoCommit(id_string='ID4', name='Four', | |
| 266 parent=result2, position=-200) | |
| 267 proto1b, result1b = DoCommit(original=result1, | |
| 268 parent=result2, position=-150) | |
| 269 proto5, result5 = DoCommit(id_string='ID5', name='Five', parent=result2, | |
| 270 position=150) | |
| 271 | |
| 272 self.assertEqual(2, len(commit_session), 'Only new items in second ' | |
| 273 'batch should be in the session') | |
| 274 for p, r, original in [(proto2b, result2b, proto2), | |
| 275 (proto4, result4, proto4), | |
| 276 (proto1b, result1b, proto1), | |
| 277 (proto5, result5, proto5)]: | |
| 278 self.assertEqual(r.originator_client_item_id, original.id_string) | |
| 279 if original is not p: | |
| 280 self.assertEqual(r.id_string, p.id_string, | |
| 281 'Ids should be stable after first commit') | |
| 282 self.assertEqual(r.originator_cache_guid, old_cache_guid) | |
| 283 else: | |
| 284 self.assertNotEqual(r.id_string, p.id_string) | |
| 285 self.assertEqual(r.originator_cache_guid, my_cache_guid) | |
| 286 self.assertEqual(commit_session.get(p.id_string), r.id_string) | |
| 287 self.assertTrue(r is not self.model._entries[r.id_string], | |
| 288 "Commit result didn't make a defensive copy.") | |
| 289 self.assertTrue(p is not self.model._entries[r.id_string], | |
| 290 "Commit didn't make a defensive copy.") | |
| 291 self.assertTrue(r.version > p.version) | |
| 292 version, changes, remaining = ( | |
| 293 self.GetChangesFromTimestamp([sync_type], original_version)) | |
| 294 self.assertEqual(5, len(changes)) | |
| 295 self.assertEqual(0, remaining) | |
| 296 self.assertEqual(original_version + 7, version) | |
| 297 self.assertEqual([result3, result2b, result4, result1b, result5], changes) | |
| 298 for c in changes: | |
| 299 self.assertTrue(c is not self.model._entries[c.id_string], | |
| 300 "GetChanges didn't make a defensive copy.") | |
| 301 self.assertTrue(result4.parent_id_string == | |
| 302 result1b.parent_id_string == | |
| 303 result5.parent_id_string == | |
| 304 result2b.id_string) | |
| 305 self.assertTrue(result4.position_in_parent < | |
| 306 result1b.position_in_parent < | |
| 307 result5.position_in_parent) | |
| 308 | |
| 309 def testUpdateSieve(self): | |
| 310 # from_timestamp, legacy mode | |
| 311 autofill = chromiumsync.SYNC_TYPE_FIELDS['autofill'] | |
| 312 theme = chromiumsync.SYNC_TYPE_FIELDS['theme'] | |
| 313 msg = sync_pb2.GetUpdatesMessage() | |
| 314 msg.from_timestamp = 15412 | |
| 315 msg.requested_types.autofill.SetInParent() | |
| 316 msg.requested_types.theme.SetInParent() | |
| 317 | |
| 318 sieve = chromiumsync.UpdateSieve(msg) | |
| 319 self.assertEqual(sieve._state, | |
| 320 {chromiumsync.TOP_LEVEL: 15412, | |
| 321 chromiumsync.AUTOFILL: 15412, | |
| 322 chromiumsync.THEME: 15412}) | |
| 323 | |
| 324 response = sync_pb2.GetUpdatesResponse() | |
| 325 sieve.SaveProgress(15412, response) | |
| 326 self.assertEqual(0, len(response.new_progress_marker)) | |
| 327 self.assertFalse(response.HasField('new_timestamp')) | |
| 328 | |
| 329 response = sync_pb2.GetUpdatesResponse() | |
| 330 sieve.SaveProgress(15413, response) | |
| 331 self.assertEqual(0, len(response.new_progress_marker)) | |
| 332 self.assertTrue(response.HasField('new_timestamp')) | |
| 333 self.assertEqual(15413, response.new_timestamp) | |
| 334 | |
| 335 # Existing tokens | |
| 336 msg = sync_pb2.GetUpdatesMessage() | |
| 337 marker = msg.from_progress_marker.add() | |
| 338 marker.data_type_id = autofill.number | |
| 339 marker.token = pickle.dumps((15412, 1)) | |
| 340 marker = msg.from_progress_marker.add() | |
| 341 marker.data_type_id = theme.number | |
| 342 marker.token = pickle.dumps((15413, 1)) | |
| 343 sieve = chromiumsync.UpdateSieve(msg) | |
| 344 self.assertEqual(sieve._state, | |
| 345 {chromiumsync.TOP_LEVEL: 15412, | |
| 346 chromiumsync.AUTOFILL: 15412, | |
| 347 chromiumsync.THEME: 15413}) | |
| 348 | |
| 349 response = sync_pb2.GetUpdatesResponse() | |
| 350 sieve.SaveProgress(15413, response) | |
| 351 self.assertEqual(1, len(response.new_progress_marker)) | |
| 352 self.assertFalse(response.HasField('new_timestamp')) | |
| 353 marker = response.new_progress_marker[0] | |
| 354 self.assertEqual(marker.data_type_id, autofill.number) | |
| 355 self.assertEqual(pickle.loads(marker.token), (15413, 1)) | |
| 356 self.assertFalse(marker.HasField('timestamp_token_for_migration')) | |
| 357 | |
| 358 # Empty tokens indicating from timestamp = 0 | |
| 359 msg = sync_pb2.GetUpdatesMessage() | |
| 360 marker = msg.from_progress_marker.add() | |
| 361 marker.data_type_id = autofill.number | |
| 362 marker.token = pickle.dumps((412, 1)) | |
| 363 marker = msg.from_progress_marker.add() | |
| 364 marker.data_type_id = theme.number | |
| 365 marker.token = '' | |
| 366 sieve = chromiumsync.UpdateSieve(msg) | |
| 367 self.assertEqual(sieve._state, | |
| 368 {chromiumsync.TOP_LEVEL: 0, | |
| 369 chromiumsync.AUTOFILL: 412, | |
| 370 chromiumsync.THEME: 0}) | |
| 371 response = sync_pb2.GetUpdatesResponse() | |
| 372 sieve.SaveProgress(1, response) | |
| 373 self.assertEqual(1, len(response.new_progress_marker)) | |
| 374 self.assertFalse(response.HasField('new_timestamp')) | |
| 375 marker = response.new_progress_marker[0] | |
| 376 self.assertEqual(marker.data_type_id, theme.number) | |
| 377 self.assertEqual(pickle.loads(marker.token), (1, 1)) | |
| 378 self.assertFalse(marker.HasField('timestamp_token_for_migration')) | |
| 379 | |
| 380 response = sync_pb2.GetUpdatesResponse() | |
| 381 sieve.SaveProgress(412, response) | |
| 382 self.assertEqual(1, len(response.new_progress_marker)) | |
| 383 self.assertFalse(response.HasField('new_timestamp')) | |
| 384 marker = response.new_progress_marker[0] | |
| 385 self.assertEqual(marker.data_type_id, theme.number) | |
| 386 self.assertEqual(pickle.loads(marker.token), (412, 1)) | |
| 387 self.assertFalse(marker.HasField('timestamp_token_for_migration')) | |
| 388 | |
| 389 response = sync_pb2.GetUpdatesResponse() | |
| 390 sieve.SaveProgress(413, response) | |
| 391 self.assertEqual(2, len(response.new_progress_marker)) | |
| 392 self.assertFalse(response.HasField('new_timestamp')) | |
| 393 marker = self.FindMarkerByNumber(response.new_progress_marker, theme) | |
| 394 self.assertEqual(pickle.loads(marker.token), (413, 1)) | |
| 395 self.assertFalse(marker.HasField('timestamp_token_for_migration')) | |
| 396 marker = self.FindMarkerByNumber(response.new_progress_marker, autofill) | |
| 397 self.assertEqual(pickle.loads(marker.token), (413, 1)) | |
| 398 self.assertFalse(marker.HasField('timestamp_token_for_migration')) | |
| 399 | |
| 400 # Migration token timestamps (client gives timestamp, server returns token) | |
| 401 # These are for migrating from the old 'timestamp' protocol to the | |
| 402 # progressmarker protocol, and have nothing to do with the MIGRATION_DONE | |
| 403 # error code. | |
| 404 msg = sync_pb2.GetUpdatesMessage() | |
| 405 marker = msg.from_progress_marker.add() | |
| 406 marker.data_type_id = autofill.number | |
| 407 marker.timestamp_token_for_migration = 15213 | |
| 408 marker = msg.from_progress_marker.add() | |
| 409 marker.data_type_id = theme.number | |
| 410 marker.timestamp_token_for_migration = 15211 | |
| 411 sieve = chromiumsync.UpdateSieve(msg) | |
| 412 self.assertEqual(sieve._state, | |
| 413 {chromiumsync.TOP_LEVEL: 15211, | |
| 414 chromiumsync.AUTOFILL: 15213, | |
| 415 chromiumsync.THEME: 15211}) | |
| 416 response = sync_pb2.GetUpdatesResponse() | |
| 417 sieve.SaveProgress(16000, response) # There were updates | |
| 418 self.assertEqual(2, len(response.new_progress_marker)) | |
| 419 self.assertFalse(response.HasField('new_timestamp')) | |
| 420 marker = self.FindMarkerByNumber(response.new_progress_marker, theme) | |
| 421 self.assertEqual(pickle.loads(marker.token), (16000, 1)) | |
| 422 self.assertFalse(marker.HasField('timestamp_token_for_migration')) | |
| 423 marker = self.FindMarkerByNumber(response.new_progress_marker, autofill) | |
| 424 self.assertEqual(pickle.loads(marker.token), (16000, 1)) | |
| 425 self.assertFalse(marker.HasField('timestamp_token_for_migration')) | |
| 426 | |
| 427 msg = sync_pb2.GetUpdatesMessage() | |
| 428 marker = msg.from_progress_marker.add() | |
| 429 marker.data_type_id = autofill.number | |
| 430 marker.timestamp_token_for_migration = 3000 | |
| 431 marker = msg.from_progress_marker.add() | |
| 432 marker.data_type_id = theme.number | |
| 433 marker.timestamp_token_for_migration = 3000 | |
| 434 sieve = chromiumsync.UpdateSieve(msg) | |
| 435 self.assertEqual(sieve._state, | |
| 436 {chromiumsync.TOP_LEVEL: 3000, | |
| 437 chromiumsync.AUTOFILL: 3000, | |
| 438 chromiumsync.THEME: 3000}) | |
| 439 response = sync_pb2.GetUpdatesResponse() | |
| 440 sieve.SaveProgress(3000, response) # Already up to date | |
| 441 self.assertEqual(2, len(response.new_progress_marker)) | |
| 442 self.assertFalse(response.HasField('new_timestamp')) | |
| 443 marker = self.FindMarkerByNumber(response.new_progress_marker, theme) | |
| 444 self.assertEqual(pickle.loads(marker.token), (3000, 1)) | |
| 445 self.assertFalse(marker.HasField('timestamp_token_for_migration')) | |
| 446 marker = self.FindMarkerByNumber(response.new_progress_marker, autofill) | |
| 447 self.assertEqual(pickle.loads(marker.token), (3000, 1)) | |
| 448 self.assertFalse(marker.HasField('timestamp_token_for_migration')) | |
| 449 | |
| 450 def testCheckRaiseTransientError(self): | |
| 451 testserver = chromiumsync.TestServer() | |
| 452 http_code, raw_respon = testserver.HandleSetTransientError() | |
| 453 self.assertEqual(http_code, 200) | |
| 454 try: | |
| 455 testserver.CheckTransientError() | |
| 456 self.fail('Should have raised transient error exception') | |
| 457 except chromiumsync.TransientError: | |
| 458 self.assertTrue(testserver.transient_error) | |
| 459 | |
| 460 def testUpdateSieveStoreMigration(self): | |
| 461 autofill = chromiumsync.SYNC_TYPE_FIELDS['autofill'] | |
| 462 theme = chromiumsync.SYNC_TYPE_FIELDS['theme'] | |
| 463 migrator = chromiumsync.MigrationHistory() | |
| 464 msg = sync_pb2.GetUpdatesMessage() | |
| 465 marker = msg.from_progress_marker.add() | |
| 466 marker.data_type_id = autofill.number | |
| 467 marker.token = pickle.dumps((15412, 1)) | |
| 468 marker = msg.from_progress_marker.add() | |
| 469 marker.data_type_id = theme.number | |
| 470 marker.token = pickle.dumps((15413, 1)) | |
| 471 sieve = chromiumsync.UpdateSieve(msg, migrator) | |
| 472 sieve.CheckMigrationState() | |
| 473 | |
| 474 migrator.Bump([chromiumsync.BOOKMARK, chromiumsync.PASSWORD]) # v=2 | |
| 475 sieve = chromiumsync.UpdateSieve(msg, migrator) | |
| 476 sieve.CheckMigrationState() | |
| 477 self.assertEqual(sieve._state, | |
| 478 {chromiumsync.TOP_LEVEL: 15412, | |
| 479 chromiumsync.AUTOFILL: 15412, | |
| 480 chromiumsync.THEME: 15413}) | |
| 481 | |
| 482 migrator.Bump([chromiumsync.AUTOFILL, chromiumsync.PASSWORD]) # v=3 | |
| 483 sieve = chromiumsync.UpdateSieve(msg, migrator) | |
| 484 try: | |
| 485 sieve.CheckMigrationState() | |
| 486 self.fail('Should have raised.') | |
| 487 except chromiumsync.MigrationDoneError, error: | |
| 488 # We want this to happen. | |
| 489 self.assertEqual([chromiumsync.AUTOFILL], error.datatypes) | |
| 490 | |
| 491 msg = sync_pb2.GetUpdatesMessage() | |
| 492 marker = msg.from_progress_marker.add() | |
| 493 marker.data_type_id = autofill.number | |
| 494 marker.token = '' | |
| 495 marker = msg.from_progress_marker.add() | |
| 496 marker.data_type_id = theme.number | |
| 497 marker.token = pickle.dumps((15413, 1)) | |
| 498 sieve = chromiumsync.UpdateSieve(msg, migrator) | |
| 499 sieve.CheckMigrationState() | |
| 500 response = sync_pb2.GetUpdatesResponse() | |
| 501 sieve.SaveProgress(15412, response) # There were updates | |
| 502 self.assertEqual(1, len(response.new_progress_marker)) | |
| 503 self.assertFalse(response.HasField('new_timestamp')) | |
| 504 self.assertFalse(marker.HasField('timestamp_token_for_migration')) | |
| 505 marker = self.FindMarkerByNumber(response.new_progress_marker, autofill) | |
| 506 self.assertEqual(pickle.loads(marker.token), (15412, 3)) | |
| 507 self.assertFalse(marker.HasField('timestamp_token_for_migration')) | |
| 508 msg = sync_pb2.GetUpdatesMessage() | |
| 509 marker = msg.from_progress_marker.add() | |
| 510 marker.data_type_id = autofill.number | |
| 511 marker.token = pickle.dumps((15412, 3)) | |
| 512 marker = msg.from_progress_marker.add() | |
| 513 marker.data_type_id = theme.number | |
| 514 marker.token = pickle.dumps((15413, 1)) | |
| 515 sieve = chromiumsync.UpdateSieve(msg, migrator) | |
| 516 sieve.CheckMigrationState() | |
| 517 | |
| 518 migrator.Bump([chromiumsync.THEME, chromiumsync.AUTOFILL]) # v=4 | |
| 519 migrator.Bump([chromiumsync.AUTOFILL]) # v=5 | |
| 520 sieve = chromiumsync.UpdateSieve(msg, migrator) | |
| 521 try: | |
| 522 sieve.CheckMigrationState() | |
| 523 self.fail("Should have raised.") | |
| 524 except chromiumsync.MigrationDoneError, error: | |
| 525 # We want this to happen. | |
| 526 self.assertEqual(set([chromiumsync.THEME, chromiumsync.AUTOFILL]), | |
| 527 set(error.datatypes)) | |
| 528 msg = sync_pb2.GetUpdatesMessage() | |
| 529 marker = msg.from_progress_marker.add() | |
| 530 marker.data_type_id = autofill.number | |
| 531 marker.token = '' | |
| 532 marker = msg.from_progress_marker.add() | |
| 533 marker.data_type_id = theme.number | |
| 534 marker.token = pickle.dumps((15413, 1)) | |
| 535 sieve = chromiumsync.UpdateSieve(msg, migrator) | |
| 536 try: | |
| 537 sieve.CheckMigrationState() | |
| 538 self.fail("Should have raised.") | |
| 539 except chromiumsync.MigrationDoneError, error: | |
| 540 # We want this to happen. | |
| 541 self.assertEqual([chromiumsync.THEME], error.datatypes) | |
| 542 | |
| 543 msg = sync_pb2.GetUpdatesMessage() | |
| 544 marker = msg.from_progress_marker.add() | |
| 545 marker.data_type_id = autofill.number | |
| 546 marker.token = '' | |
| 547 marker = msg.from_progress_marker.add() | |
| 548 marker.data_type_id = theme.number | |
| 549 marker.token = '' | |
| 550 sieve = chromiumsync.UpdateSieve(msg, migrator) | |
| 551 sieve.CheckMigrationState() | |
| 552 response = sync_pb2.GetUpdatesResponse() | |
| 553 sieve.SaveProgress(15412, response) # There were updates | |
| 554 self.assertEqual(2, len(response.new_progress_marker)) | |
| 555 self.assertFalse(response.HasField('new_timestamp')) | |
| 556 self.assertFalse(marker.HasField('timestamp_token_for_migration')) | |
| 557 marker = self.FindMarkerByNumber(response.new_progress_marker, autofill) | |
| 558 self.assertEqual(pickle.loads(marker.token), (15412, 5)) | |
| 559 self.assertFalse(marker.HasField('timestamp_token_for_migration')) | |
| 560 marker = self.FindMarkerByNumber(response.new_progress_marker, theme) | |
| 561 self.assertEqual(pickle.loads(marker.token), (15412, 4)) | |
| 562 self.assertFalse(marker.HasField('timestamp_token_for_migration')) | |
| 563 msg = sync_pb2.GetUpdatesMessage() | |
| 564 marker = msg.from_progress_marker.add() | |
| 565 marker.data_type_id = autofill.number | |
| 566 marker.token = pickle.dumps((15412, 5)) | |
| 567 marker = msg.from_progress_marker.add() | |
| 568 marker.data_type_id = theme.number | |
| 569 marker.token = pickle.dumps((15413, 4)) | |
| 570 sieve = chromiumsync.UpdateSieve(msg, migrator) | |
| 571 sieve.CheckMigrationState() | |
| 572 | |
| 573 def testCreateSyncedBookmarks(self): | |
| 574 version1, changes, remaining = ( | |
| 575 self.GetChangesFromTimestamp([chromiumsync.BOOKMARK], 0)) | |
| 576 id_string = self.model._MakeCurrentId(chromiumsync.BOOKMARK, | |
| 577 '<server tag>synced_bookmarks') | |
| 578 self.assertFalse(self.model._ItemExists(id_string)) | |
| 579 self._expect_synced_bookmarks_folder = True | |
| 580 self.model.TriggerCreateSyncedBookmarks() | |
| 581 self.assertTrue(self.model._ItemExists(id_string)) | |
| 582 | |
| 583 # Check that the version changed when the folder was created and the only | |
| 584 # change was the folder creation. | |
| 585 version2, changes, remaining = ( | |
| 586 self.GetChangesFromTimestamp([chromiumsync.BOOKMARK], version1)) | |
| 587 self.assertEqual(len(changes), 1) | |
| 588 self.assertEqual(changes[0].id_string, id_string) | |
| 589 self.assertNotEqual(version1, version2) | |
| 590 self.assertEqual( | |
| 591 self.ExpectedPermanentItemCount(chromiumsync.BOOKMARK), | |
| 592 version2) | |
| 593 | |
| 594 # Ensure getting from timestamp 0 includes the folder. | |
| 595 version, changes, remaining = ( | |
| 596 self.GetChangesFromTimestamp([chromiumsync.BOOKMARK], 0)) | |
| 597 self.assertEqual( | |
| 598 self.ExpectedPermanentItemCount(chromiumsync.BOOKMARK), | |
| 599 len(changes)) | |
| 600 self.assertEqual(version2, version) | |
| 601 | |
| 602 def testAcknowledgeManagedUser(self): | |
| 603 # Create permanent items. | |
| 604 self.GetChangesFromTimestamp([chromiumsync.MANAGED_USER], 0) | |
| 605 proto = sync_pb2.SyncEntity() | |
| 606 proto.id_string = 'abcd' | |
| 607 proto.version = 0 | |
| 608 | |
| 609 # Make sure the managed_user field exists. | |
| 610 proto.specifics.managed_user.acknowledged = False | |
| 611 self.assertTrue(proto.specifics.HasField('managed_user')) | |
| 612 self.AddToModel(proto) | |
| 613 version1, changes1, remaining1 = ( | |
| 614 self.GetChangesFromTimestamp([chromiumsync.MANAGED_USER], 0)) | |
| 615 for change in changes1: | |
| 616 self.assertTrue(not change.specifics.managed_user.acknowledged) | |
| 617 | |
| 618 # Turn on managed user acknowledgement | |
| 619 self.model.acknowledge_managed_users = True | |
| 620 | |
| 621 version2, changes2, remaining2 = ( | |
| 622 self.GetChangesFromTimestamp([chromiumsync.MANAGED_USER], 0)) | |
| 623 for change in changes2: | |
| 624 self.assertTrue(change.specifics.managed_user.acknowledged) | |
| 625 | |
| 626 def testGetKey(self): | |
| 627 [key1] = self.model.GetKeystoreKeys() | |
| 628 [key2] = self.model.GetKeystoreKeys() | |
| 629 self.assertTrue(len(key1)) | |
| 630 self.assertEqual(key1, key2) | |
| 631 | |
| 632 # Trigger the rotation. A subsequent GetUpdates should return the nigori | |
| 633 # node (whose timestamp was bumped by the rotation). | |
| 634 version1, changes, remaining = ( | |
| 635 self.GetChangesFromTimestamp([chromiumsync.NIGORI], 0)) | |
| 636 self.model.TriggerRotateKeystoreKeys() | |
| 637 version2, changes, remaining = ( | |
| 638 self.GetChangesFromTimestamp([chromiumsync.NIGORI], version1)) | |
| 639 self.assertNotEqual(version1, version2) | |
| 640 self.assertEquals(len(changes), 1) | |
| 641 self.assertEquals(changes[0].name, "Nigori") | |
| 642 | |
| 643 # The current keys should contain the old keys, with the new key appended. | |
| 644 [key1, key3] = self.model.GetKeystoreKeys() | |
| 645 self.assertEquals(key1, key2) | |
| 646 self.assertNotEqual(key1, key3) | |
| 647 self.assertTrue(len(key3) > 0) | |
| 648 | |
| 649 def testTriggerEnableKeystoreEncryption(self): | |
| 650 version1, changes, remaining = ( | |
| 651 self.GetChangesFromTimestamp([chromiumsync.EXPERIMENTS], 0)) | |
| 652 keystore_encryption_id_string = ( | |
| 653 self.model._ClientTagToId( | |
| 654 chromiumsync.EXPERIMENTS, | |
| 655 chromiumsync.KEYSTORE_ENCRYPTION_EXPERIMENT_TAG)) | |
| 656 | |
| 657 self.assertFalse(self.model._ItemExists(keystore_encryption_id_string)) | |
| 658 self.model.TriggerEnableKeystoreEncryption() | |
| 659 self.assertTrue(self.model._ItemExists(keystore_encryption_id_string)) | |
| 660 | |
| 661 # The creation of the experiment should be downloaded on the next | |
| 662 # GetUpdates. | |
| 663 version2, changes, remaining = ( | |
| 664 self.GetChangesFromTimestamp([chromiumsync.EXPERIMENTS], version1)) | |
| 665 self.assertEqual(len(changes), 1) | |
| 666 self.assertEqual(changes[0].id_string, keystore_encryption_id_string) | |
| 667 self.assertNotEqual(version1, version2) | |
| 668 | |
| 669 # Verify the experiment was created properly and is enabled. | |
| 670 self.assertEqual(chromiumsync.KEYSTORE_ENCRYPTION_EXPERIMENT_TAG, | |
| 671 changes[0].client_defined_unique_tag) | |
| 672 self.assertTrue(changes[0].HasField("specifics")) | |
| 673 self.assertTrue(changes[0].specifics.HasField("experiments")) | |
| 674 self.assertTrue( | |
| 675 changes[0].specifics.experiments.HasField("keystore_encryption")) | |
| 676 self.assertTrue( | |
| 677 changes[0].specifics.experiments.keystore_encryption.enabled) | |
| 678 | |
| 679 if __name__ == '__main__': | |
| 680 unittest.main() | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2130453004:
[Sync] Move //sync to //components/sync. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master