1 files changed, 173 insertions, 18 deletions
diff --git a/net/tools/testserver/chromiumsync_test.py b/net/tools/testserver/chromiumsync_test.py
index f753c3b..844ba50 100755
--- a/net/tools/testserver/chromiumsync_test.py
+++ b/net/tools/testserver/chromiumsync_test.py
@@ -7,8 +7,10 @@
 
 import unittest
 
+import autofill_specifics_pb2
 import chromiumsync
 import sync_pb2
+import theme_specifics_pb2
 
 class SyncDataModelTest(unittest.TestCase):
   def setUp(self):
@@ -17,6 +19,14 @@ class SyncDataModelTest(unittest.TestCase):
   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
 
@@ -112,12 +122,13 @@ class SyncDataModelTest(unittest.TestCase):
       return 2
 
   def testGetChangesFromTimestampZeroForEachType(self):
-    for sync_type in chromiumsync.ALL_TYPES:
+    all_types = chromiumsync.ALL_TYPES[1:]
+    for sync_type in all_types:
       self.model = chromiumsync.SyncDataModel()
-      request_types = [sync_type, chromiumsync.TOP_LEVEL]
+      request_types = [sync_type]
 
       version, changes, remaining = (
-          self.model.GetChangesFromTimestamp(request_types, 0))
+          self.GetChangesFromTimestamp(request_types, 0))
 
       expected_count = self.ExpectedPermanentItemCount(sync_type)
       self.assertEqual(expected_count, version)
@@ -130,20 +141,20 @@ class SyncDataModelTest(unittest.TestCase):
 
       # Test idempotence: another GetUpdates from ts=0 shouldn't recreate.
       version, changes, remaining = (
-          self.model.GetChangesFromTimestamp(request_types, 0))
+          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.model.GetChangesFromTimestamp(chromiumsync.ALL_TYPES, 0))
+          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.model.GetChangesFromTimestamp(request_types, 0))
+          self.GetChangesFromTimestamp(request_types, 0))
       self.assertEqual(new_version, version)
       self.assertEqual(expected_count, len(changes))
       self.assertEqual(0, remaining)
@@ -152,7 +163,7 @@ class SyncDataModelTest(unittest.TestCase):
     for sync_type in chromiumsync.ALL_TYPES[1:]:
       specifics = chromiumsync.GetDefaultEntitySpecifics(sync_type)
       self.model = chromiumsync.SyncDataModel()
-      request_types = [sync_type, chromiumsync.TOP_LEVEL]
+      request_types = [sync_type]
 
       for i in range(self.model._BATCH_SIZE*3):
         entry = sync_pb2.SyncEntity()
@@ -161,19 +172,19 @@ class SyncDataModelTest(unittest.TestCase):
         self.model._SaveEntry(entry)
       last_bit = self.ExpectedPermanentItemCount(sync_type)
       version, changes, changes_remaining = (
-          self.model.GetChangesFromTimestamp(request_types, 0))
+          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.model.GetChangesFromTimestamp(request_types, version))
+          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.model.GetChangesFromTimestamp(request_types, version))
+          self.GetChangesFromTimestamp(request_types, version))
       self.assertEqual(self.model._BATCH_SIZE*3, version)
       self.assertEqual(last_bit, changes_remaining)
       version, changes, changes_remaining = (
-          self.model.GetChangesFromTimestamp(request_types, version))
+          self.GetChangesFromTimestamp(request_types, version))
       self.assertEqual(self.model._BATCH_SIZE*3 + last_bit, version)
       self.assertEqual(0, changes_remaining)
 
@@ -186,19 +197,19 @@ class SyncDataModelTest(unittest.TestCase):
 
       # The batch counts shouldn't change.
       version, changes, changes_remaining = (
-          self.model.GetChangesFromTimestamp(request_types, 0))
+          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.model.GetChangesFromTimestamp(request_types, version))
+          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.model.GetChangesFromTimestamp(request_types, version))
+          self.GetChangesFromTimestamp(request_types, version))
       self.assertEqual(self.model._BATCH_SIZE, len(changes))
       self.assertEqual(last_bit, changes_remaining)
       version, changes, changes_remaining = (
-          self.model.GetChangesFromTimestamp(request_types, version))
+          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)
@@ -213,7 +224,7 @@ class SyncDataModelTest(unittest.TestCase):
 
       # Start with a GetUpdates from timestamp 0, to populate permanent items.
       original_version, original_changes, changes_remaining = (
-          self.model.GetChangesFromTimestamp([sync_type], 0))
+          self.GetChangesFromTimestamp([sync_type], 0))
 
       def DoCommit(original=None, id_string='', name=None, parent=None,
                    prev=None):
@@ -266,7 +277,7 @@ class SyncDataModelTest(unittest.TestCase):
       self.assertEqual(result1.parent_id_string, proto1.parent_id_string)
       self.assertEqual(result2.parent_id_string, result1.id_string)
       version, changes, remaining = (
-          self.model.GetChangesFromTimestamp([sync_type], original_version))
+          self.GetChangesFromTimestamp([sync_type], original_version))
       self.assertEqual(3, len(changes))
       self.assertEqual(0, remaining)
       self.assertEqual(original_version + 3, version)
@@ -314,7 +325,7 @@ class SyncDataModelTest(unittest.TestCase):
                         "Commit didn't make a defensive copy.")
         self.assertTrue(r.version > p.version)
       version, changes, remaining = (
-          self.model.GetChangesFromTimestamp([sync_type], original_version))
+          self.GetChangesFromTimestamp([sync_type], original_version))
       self.assertEqual(5, len(changes))
       self.assertEqual(0, remaining)
       self.assertEqual(original_version + 7, version)
@@ -330,6 +341,150 @@ class SyncDataModelTest(unittest.TestCase):
                       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()