[Sync] Add support for associating a new Synced Bookmarks node.

net/tools/testserver/chromiumsync_test.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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 pickle
 import unittest
 
 import autofill_specifics_pb2
 import bookmark_specifics_pb2
 import chromiumsync
 import sync_pb2
 import theme_specifics_pb2
 
 class SyncDataModelTest(unittest.TestCase):
   def setUp(self):
     self.model = chromiumsync.SyncDataModel()
+    # The Synced Bookmarks folder is not created by default
+    self._expect_synced_bookmarks_folder = False
 
   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:
       getattr(message.requested_types,
               chromiumsync.SYNC_TYPE_TO_DESCRIPTOR[
@@ skipping 30 matching lines @@
     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 testCreatePermanentItems(self):
-    self.model._CreatePermanentItems(chromiumsync.ALL_TYPES)
+    self.model._CreateDefaultPermanentItems(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
+      if self._expect_synced_bookmarks_folder:
+        return 5
+      else:
+        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]
@@ skipping 13 matching lines @@
       # 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(
+          len(chromiumsync.SyncDataModel._PERMANENT_ITEM_SPECS) - 1 if not
+              self._expect_synced_bookmarks_folder else 0,

[ncarter (slow), 2012/03/15 22:44:52]

FWIW, I don't find this very readable -- it's almost an operator-precedence
puzzle.  I would probably just use an if/else pair and two asserts.

+          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:]:
@@ skipping 432 matching lines @@
     msg = sync_pb2.GetUpdatesMessage()
     marker = msg.from_progress_marker.add()
     marker.data_type_id = autofill.number
     marker.token = pickle.dumps((15412, 5))
     marker = msg.from_progress_marker.add()
     marker.data_type_id = theme.number
     marker.token = pickle.dumps((15413, 4))
     sieve = chromiumsync.UpdateSieve(msg, migrator)
     sieve.CheckMigrationState()
 
+  def testCreateSyncedBookmaks(self):
+    version1, changes, remaining = (
+        self.GetChangesFromTimestamp([chromiumsync.BOOKMARK], 0))
+    id_string = self.model._MakeCurrentId(chromiumsync.BOOKMARK,
+                                          '<server tag>synced_bookmarks')
+    self.assertFalse(self.model._ItemExists(id_string))
+    self._expect_synced_bookmarks_folder = True
+    self.model.TriggerCreateSyncedBookmarks()
+    self.assertTrue(self.model._ItemExists(id_string))
+
+    # Check that the version changed when the folder was created and the only
+    # change was the folder creation.
+    version2, changes, remaining = (
+        self.GetChangesFromTimestamp([chromiumsync.BOOKMARK], version1))
+    self.assertEqual(len(changes), 1)
+    self.assertEqual(changes[0].id_string, id_string)
+    self.assertNotEqual(version1, version2)
+    self.assertEqual(
+        self.ExpectedPermanentItemCount(chromiumsync.BOOKMARK),
+        version2)
+
+    # Ensure getting from timestamp 0 includes the folder.
+    version, changes, remaining = (
+        self.GetChangesFromTimestamp([chromiumsync.BOOKMARK], 0))
+    self.assertEqual(
+        self.ExpectedPermanentItemCount(chromiumsync.BOOKMARK),
+        len(changes))
+    self.assertEqual(version2, version)
+
 
 if __name__ == '__main__':
   unittest.main()