#!/usr/bin/python2.4 # Copyright (c) 2010 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """Tests exercising chromiumsync and SyncDataModel.""" import unittest import autofill_specifics_pb2 import chromiumsync import sync_pb2 import theme_specifics_pb2 class SyncDataModelTest(unittest.TestCase): def setUp(self): self.model = chromiumsync.SyncDataModel() def AddToModel(self, proto): self.model._entries[proto.id_string] = proto def GetChangesFromTimestamp(self, requested_types, timestamp): message = sync_pb2.GetUpdatesMessage() message.from_timestamp = timestamp for data_type in requested_types: message.requested_types.Extensions[ chromiumsync.SYNC_TYPE_TO_EXTENSION[data_type]].SetInParent() return self.model.GetChanges(chromiumsync.UpdateSieve(message)) def testPermanentItemSpecs(self): specs = chromiumsync.SyncDataModel._PERMANENT_ITEM_SPECS declared_specs = set(['0']) for spec in specs: self.assertTrue(spec.parent_tag in declared_specs, 'parent tags must ' 'be declared before use') declared_specs.add(spec.tag) unique_datatypes = set([x.sync_type for x in specs]) self.assertEqual(unique_datatypes, set(chromiumsync.ALL_TYPES), 'Every sync datatype should have a permanent folder ' 'associated with it') def testSaveEntry(self): proto = sync_pb2.SyncEntity() proto.id_string = 'abcd' proto.version = 0 self.assertFalse(self.model._ItemExists(proto.id_string)) self.model._SaveEntry(proto) self.assertEqual(1, proto.version) self.assertTrue(self.model._ItemExists(proto.id_string)) self.model._SaveEntry(proto) self.assertEqual(2, proto.version) proto.version = 0 self.assertTrue(self.model._ItemExists(proto.id_string)) self.assertEqual(2, self.model._entries[proto.id_string].version) def testWritePosition(self): def MakeProto(id_string, parent, position): proto = sync_pb2.SyncEntity() proto.id_string = id_string proto.position_in_parent = position proto.parent_id_string = parent self.AddToModel(proto) MakeProto('a', 'X', 1000) MakeProto('b', 'X', 1800) MakeProto('c', 'X', 2600) MakeProto('a1', 'Z', 1007) MakeProto('a2', 'Z', 1807) MakeProto('a3', 'Z', 2607) MakeProto('s', 'Y', 10000) def AssertPositionResult(my_id, parent_id, prev_id, expected_position): entry = sync_pb2.SyncEntity() entry.id_string = my_id self.model._WritePosition(entry, parent_id, prev_id) self.assertEqual(expected_position, entry.position_in_parent) self.assertEqual(parent_id, entry.parent_id_string) self.assertFalse(entry.HasField('insert_after_item_id')) AssertPositionResult('new', 'new_parent', '', 0) AssertPositionResult('new', 'Y', '', 10000 - (2 ** 20)) AssertPositionResult('new', 'Y', 's', 10000 + (2 ** 20)) AssertPositionResult('s', 'Y', '', 10000) AssertPositionResult('s', 'Y', 's', 10000) AssertPositionResult('a1', 'Z', '', 1007) AssertPositionResult('new', 'X', '', 1000 - (2 ** 20)) AssertPositionResult('new', 'X', 'a', 1100) AssertPositionResult('new', 'X', 'b', 1900) AssertPositionResult('new', 'X', 'c', 2600 + (2 ** 20)) AssertPositionResult('a1', 'X', '', 1000 - (2 ** 20)) AssertPositionResult('a1', 'X', 'a', 1100) AssertPositionResult('a1', 'X', 'b', 1900) AssertPositionResult('a1', 'X', 'c', 2600 + (2 ** 20)) AssertPositionResult('a', 'X', '', 1000) AssertPositionResult('a', 'X', 'b', 1900) AssertPositionResult('a', 'X', 'c', 2600 + (2 ** 20)) AssertPositionResult('b', 'X', '', 1000 - (2 ** 20)) AssertPositionResult('b', 'X', 'a', 1800) AssertPositionResult('b', 'X', 'c', 2600 + (2 ** 20)) AssertPositionResult('c', 'X', '', 1000 - (2 ** 20)) AssertPositionResult('c', 'X', 'a', 1100) AssertPositionResult('c', 'X', 'b', 2600) def testCreatePermanentItems(self): self.model._CreatePermanentItems(chromiumsync.ALL_TYPES) self.assertEqual(len(chromiumsync.ALL_TYPES) + 2, len(self.model._entries)) def ExpectedPermanentItemCount(self, sync_type): if sync_type == chromiumsync.BOOKMARK: return 4 elif sync_type == chromiumsync.TOP_LEVEL: return 1 else: return 2 def testGetChangesFromTimestampZeroForEachType(self): all_types = chromiumsync.ALL_TYPES[1:] for sync_type in all_types: self.model = chromiumsync.SyncDataModel() request_types = [sync_type] version, changes, remaining = ( self.GetChangesFromTimestamp(request_types, 0)) expected_count = self.ExpectedPermanentItemCount(sync_type) self.assertEqual(expected_count, version) self.assertEqual(expected_count, len(changes)) self.assertEqual('google_chrome', changes[0].server_defined_unique_tag) for change in changes: self.assertTrue(change.HasField('server_defined_unique_tag')) self.assertEqual(change.version, change.sync_timestamp) self.assertTrue(change.version <= version) # Test idempotence: another GetUpdates from ts=0 shouldn't recreate. version, changes, remaining = ( self.GetChangesFromTimestamp(request_types, 0)) self.assertEqual(expected_count, version) self.assertEqual(expected_count, len(changes)) self.assertEqual(0, remaining) # Doing a wider GetUpdates from timestamp zero shouldn't recreate either. new_version, changes, remaining = ( self.GetChangesFromTimestamp(all_types, 0)) self.assertEqual(len(chromiumsync.SyncDataModel._PERMANENT_ITEM_SPECS), new_version) self.assertEqual(new_version, len(changes)) self.assertEqual(0, remaining) version, changes, remaining = ( self.GetChangesFromTimestamp(request_types, 0)) self.assertEqual(new_version, version) self.assertEqual(expected_count, len(changes)) self.assertEqual(0, remaining) def testBatchSize(self): for sync_type in chromiumsync.ALL_TYPES[1:]: specifics = chromiumsync.GetDefaultEntitySpecifics(sync_type) self.model = chromiumsync.SyncDataModel() request_types = [sync_type] for i in range(self.model._BATCH_SIZE*3): entry = sync_pb2.SyncEntity() entry.id_string = 'batch test %d' % i entry.specifics.CopyFrom(specifics) self.model._SaveEntry(entry) last_bit = self.ExpectedPermanentItemCount(sync_type) version, changes, changes_remaining = ( self.GetChangesFromTimestamp(request_types, 0)) self.assertEqual(self.model._BATCH_SIZE, version) self.assertEqual(self.model._BATCH_SIZE*2 + last_bit, changes_remaining) version, changes, changes_remaining = ( self.GetChangesFromTimestamp(request_types, version)) self.assertEqual(self.model._BATCH_SIZE*2, version) self.assertEqual(self.model._BATCH_SIZE + last_bit, changes_remaining) version, changes, changes_remaining = ( self.GetChangesFromTimestamp(request_types, version)) self.assertEqual(self.model._BATCH_SIZE*3, version) self.assertEqual(last_bit, changes_remaining) version, changes, changes_remaining = ( self.GetChangesFromTimestamp(request_types, version)) self.assertEqual(self.model._BATCH_SIZE*3 + last_bit, version) self.assertEqual(0, changes_remaining) # Now delete a third of the items. for i in xrange(self.model._BATCH_SIZE*3 - 1, 0, -3): entry = sync_pb2.SyncEntity() entry.id_string = 'batch test %d' % i entry.deleted = True self.model._SaveEntry(entry) # The batch counts shouldn't change. version, changes, changes_remaining = ( self.GetChangesFromTimestamp(request_types, 0)) self.assertEqual(self.model._BATCH_SIZE, len(changes)) self.assertEqual(self.model._BATCH_SIZE*2 + last_bit, changes_remaining) version, changes, changes_remaining = ( self.GetChangesFromTimestamp(request_types, version)) self.assertEqual(self.model._BATCH_SIZE, len(changes)) self.assertEqual(self.model._BATCH_SIZE + last_bit, changes_remaining) version, changes, changes_remaining = ( self.GetChangesFromTimestamp(request_types, version)) self.assertEqual(self.model._BATCH_SIZE, len(changes)) self.assertEqual(last_bit, changes_remaining) version, changes, changes_remaining = ( self.GetChangesFromTimestamp(request_types, version)) self.assertEqual(last_bit, len(changes)) self.assertEqual(self.model._BATCH_SIZE*4 + last_bit, version) self.assertEqual(0, changes_remaining) def testCommitEachDataType(self): for sync_type in chromiumsync.ALL_TYPES[1:]: specifics = chromiumsync.GetDefaultEntitySpecifics(sync_type) self.model = chromiumsync.SyncDataModel() my_cache_guid = '112358132134' parent = 'foobar' commit_session = {} # Start with a GetUpdates from timestamp 0, to populate permanent items. original_version, original_changes, changes_remaining = ( self.GetChangesFromTimestamp([sync_type], 0)) def DoCommit(original=None, id_string='', name=None, parent=None, prev=None): proto = sync_pb2.SyncEntity() if original is not None: proto.version = original.version proto.id_string = original.id_string proto.parent_id_string = original.parent_id_string proto.name = original.name else: proto.id_string = id_string proto.version = 0 proto.specifics.CopyFrom(specifics) if name is not None: proto.name = name if parent: proto.parent_id_string = parent.id_string if prev: proto.insert_after_item_id = prev.id_string else: proto.insert_after_item_id = '' proto.folder = True proto.deleted = False result = self.model.CommitEntry(proto, my_cache_guid, commit_session) self.assertTrue(result) return (proto, result) # Commit a new item. proto1, result1 = DoCommit(name='namae', id_string='Foo', parent=original_changes[-1]) # Commit an item whose parent is another item (referenced via the # pre-commit ID). proto2, result2 = DoCommit(name='Secondo', id_string='Bar', parent=proto1) # Commit a sibling of the second item. proto3, result3 = DoCommit(name='Third!', id_string='Baz', parent=proto1, prev=proto2) self.assertEqual(3, len(commit_session)) for p, r in [(proto1, result1), (proto2, result2), (proto3, result3)]: self.assertNotEqual(r.id_string, p.id_string) self.assertEqual(r.originator_client_item_id, p.id_string) self.assertEqual(r.originator_cache_guid, my_cache_guid) self.assertTrue(r is not self.model._entries[r.id_string], "Commit result didn't make a defensive copy.") self.assertTrue(p is not self.model._entries[r.id_string], "Commit result didn't make a defensive copy.") self.assertEqual(commit_session.get(p.id_string), r.id_string) self.assertTrue(r.version > original_version) self.assertEqual(result1.parent_id_string, proto1.parent_id_string) self.assertEqual(result2.parent_id_string, result1.id_string) version, changes, remaining = ( self.GetChangesFromTimestamp([sync_type], original_version)) self.assertEqual(3, len(changes)) self.assertEqual(0, remaining) self.assertEqual(original_version + 3, version) self.assertEqual([result1, result2, result3], changes) for c in changes: self.assertTrue(c is not self.model._entries[c.id_string], "GetChanges didn't make a defensive copy.") self.assertTrue(result2.position_in_parent < result3.position_in_parent) self.assertEqual(0, result2.position_in_parent) # Now update the items so that the second item is the parent of the # first; with the first sandwiched between two new items (4 and 5). # Do this in a new commit session, meaning we'll reference items from # the first batch by their post-commit, server IDs. commit_session = {} old_cache_guid = my_cache_guid my_cache_guid = 'A different GUID' proto2b, result2b = DoCommit(original=result2, parent=original_changes[-1]) proto4, result4 = DoCommit(id_string='ID4', name='Four', parent=result2, prev=None) proto1b, result1b = DoCommit(original=result1, parent=result2, prev=proto4) proto5, result5 = DoCommit(id_string='ID5', name='Five', parent=result2, prev=result1) self.assertEqual(2, len(commit_session), 'Only new items in second ' 'batch should be in the session') for p, r, original in [(proto2b, result2b, proto2), (proto4, result4, proto4), (proto1b, result1b, proto1), (proto5, result5, proto5)]: self.assertEqual(r.originator_client_item_id, original.id_string) if original is not p: self.assertEqual(r.id_string, p.id_string, 'Ids should be stable after first commit') self.assertEqual(r.originator_cache_guid, old_cache_guid) else: self.assertNotEqual(r.id_string, p.id_string) self.assertEqual(r.originator_cache_guid, my_cache_guid) self.assertEqual(commit_session.get(p.id_string), r.id_string) self.assertTrue(r is not self.model._entries[r.id_string], "Commit result didn't make a defensive copy.") self.assertTrue(p is not self.model._entries[r.id_string], "Commit didn't make a defensive copy.") self.assertTrue(r.version > p.version) version, changes, remaining = ( self.GetChangesFromTimestamp([sync_type], original_version)) self.assertEqual(5, len(changes)) self.assertEqual(0, remaining) self.assertEqual(original_version + 7, version) self.assertEqual([result3, result2b, result4, result1b, result5], changes) for c in changes: self.assertTrue(c is not self.model._entries[c.id_string], "GetChanges didn't make a defensive copy.") self.assertTrue(result4.parent_id_string == result1b.parent_id_string == result5.parent_id_string == result2b.id_string) self.assertTrue(result4.position_in_parent < result1b.position_in_parent < result5.position_in_parent) def testUpdateSieve(self): # from_timestamp, legacy mode autofill = autofill_specifics_pb2.autofill theme = theme_specifics_pb2.theme msg = sync_pb2.GetUpdatesMessage() msg.from_timestamp = 15412 msg.requested_types.Extensions[autofill].SetInParent() msg.requested_types.Extensions[theme].SetInParent() sieve = chromiumsync.UpdateSieve(msg) self.assertEqual(sieve._state, {chromiumsync.TOP_LEVEL: 15412, chromiumsync.AUTOFILL: 15412, chromiumsync.THEME: 15412}) response = sync_pb2.GetUpdatesResponse() sieve.SaveProgress(15412, response) self.assertEqual(0, len(response.new_progress_marker)) self.assertFalse(response.HasField('new_timestamp')) response = sync_pb2.GetUpdatesResponse() sieve.SaveProgress(15413, response) self.assertEqual(0, len(response.new_progress_marker)) self.assertTrue(response.HasField('new_timestamp')) self.assertEqual(15413, response.new_timestamp) # Existing tokens msg = sync_pb2.GetUpdatesMessage() marker = msg.from_progress_marker.add() marker.data_type_id = autofill.number marker.token = '15412' marker = msg.from_progress_marker.add() marker.data_type_id = theme.number marker.token = '15413' sieve = chromiumsync.UpdateSieve(msg) self.assertEqual(sieve._state, {chromiumsync.TOP_LEVEL: 15412, chromiumsync.AUTOFILL: 15412, chromiumsync.THEME: 15413}) response = sync_pb2.GetUpdatesResponse() sieve.SaveProgress(15413, response) self.assertEqual(1, len(response.new_progress_marker)) self.assertFalse(response.HasField('new_timestamp')) marker = response.new_progress_marker[0] self.assertEqual(marker.data_type_id, autofill.number) self.assertEqual(marker.token, '15413') self.assertFalse(marker.HasField('timestamp_token_for_migration')) # Empty tokens indicating from timestamp = 0 msg = sync_pb2.GetUpdatesMessage() marker = msg.from_progress_marker.add() marker.data_type_id = autofill.number marker.token = '412' marker = msg.from_progress_marker.add() marker.data_type_id = theme.number marker.token = '' sieve = chromiumsync.UpdateSieve(msg) self.assertEqual(sieve._state, {chromiumsync.TOP_LEVEL: 0, chromiumsync.AUTOFILL: 412, chromiumsync.THEME: 0}) response = sync_pb2.GetUpdatesResponse() sieve.SaveProgress(1, response) self.assertEqual(1, len(response.new_progress_marker)) self.assertFalse(response.HasField('new_timestamp')) marker = response.new_progress_marker[0] self.assertEqual(marker.data_type_id, theme.number) self.assertEqual(marker.token, '1') self.assertFalse(marker.HasField('timestamp_token_for_migration')) response = sync_pb2.GetUpdatesResponse() sieve.SaveProgress(412, response) self.assertEqual(1, len(response.new_progress_marker)) self.assertFalse(response.HasField('new_timestamp')) marker = response.new_progress_marker[0] self.assertEqual(marker.data_type_id, theme.number) self.assertEqual(marker.token, '412') self.assertFalse(marker.HasField('timestamp_token_for_migration')) response = sync_pb2.GetUpdatesResponse() sieve.SaveProgress(413, response) self.assertEqual(2, len(response.new_progress_marker)) self.assertFalse(response.HasField('new_timestamp')) marker = response.new_progress_marker[0] self.assertEqual(marker.data_type_id, theme.number) self.assertEqual(marker.token, '413') self.assertFalse(marker.HasField('timestamp_token_for_migration')) marker = response.new_progress_marker[1] self.assertEqual(marker.data_type_id, autofill.number) self.assertEqual(marker.token, '413') self.assertFalse(marker.HasField('timestamp_token_for_migration')) # Migration token timestamps (client gives timestamp, server returns token) msg = sync_pb2.GetUpdatesMessage() marker = msg.from_progress_marker.add() marker.data_type_id = autofill.number marker.timestamp_token_for_migration = 15213 marker = msg.from_progress_marker.add() marker.data_type_id = theme.number marker.timestamp_token_for_migration = 15211 sieve = chromiumsync.UpdateSieve(msg) self.assertEqual(sieve._state, {chromiumsync.TOP_LEVEL: 15211, chromiumsync.AUTOFILL: 15213, chromiumsync.THEME: 15211}) response = sync_pb2.GetUpdatesResponse() sieve.SaveProgress(16000, response) # There were updates self.assertEqual(2, len(response.new_progress_marker)) self.assertFalse(response.HasField('new_timestamp')) marker = response.new_progress_marker[0] self.assertEqual(marker.data_type_id, theme.number) self.assertEqual(marker.token, '16000') self.assertFalse(marker.HasField('timestamp_token_for_migration')) marker = response.new_progress_marker[1] self.assertEqual(marker.data_type_id, autofill.number) self.assertEqual(marker.token, '16000') self.assertFalse(marker.HasField('timestamp_token_for_migration')) msg = sync_pb2.GetUpdatesMessage() marker = msg.from_progress_marker.add() marker.data_type_id = autofill.number marker.timestamp_token_for_migration = 3000 marker = msg.from_progress_marker.add() marker.data_type_id = theme.number marker.timestamp_token_for_migration = 3000 sieve = chromiumsync.UpdateSieve(msg) self.assertEqual(sieve._state, {chromiumsync.TOP_LEVEL: 3000, chromiumsync.AUTOFILL: 3000, chromiumsync.THEME: 3000}) response = sync_pb2.GetUpdatesResponse() sieve.SaveProgress(3000, response) # Already up to date self.assertEqual(2, len(response.new_progress_marker)) self.assertFalse(response.HasField('new_timestamp')) marker = response.new_progress_marker[0] self.assertEqual(marker.data_type_id, theme.number) self.assertEqual(marker.token, '3000') self.assertFalse(marker.HasField('timestamp_token_for_migration')) marker = response.new_progress_marker[1] self.assertEqual(marker.data_type_id, autofill.number) self.assertEqual(marker.token, '3000') self.assertFalse(marker.HasField('timestamp_token_for_migration')) if __name__ == '__main__': unittest.main()