WIP: The Bookmark Position Megapatch

sync/engine/apply_updates_and_resolve_conflicts_command_unittest.cc

 // 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.
 
 #include <string>
 
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stringprintf.h"
 #include "sync/engine/apply_updates_and_resolve_conflicts_command.h"
@@ skipping 53 matching lines @@
 
  protected:
   DISALLOW_COPY_AND_ASSIGN(ApplyUpdatesAndResolveConflictsCommandTest);
 
   ApplyUpdatesAndResolveConflictsCommand apply_updates_command_;
   scoped_ptr<TestEntryFactory> entry_factory_;
 };
 
 TEST_F(ApplyUpdatesAndResolveConflictsCommandTest, Simple) {
   string root_server_id = syncable::GetNullId().GetServerId();
-  entry_factory_->CreateUnappliedNewItemWithParent("parent",
-                                                   DefaultBookmarkSpecifics(),
-                                                   root_server_id);
-  entry_factory_->CreateUnappliedNewItemWithParent("child",
-                                                   DefaultBookmarkSpecifics(),
-                                                   "parent");
+  entry_factory_->CreateUnappliedNewBookmarkItemWithParent(
+      "parent", DefaultBookmarkSpecifics(), root_server_id);
+  entry_factory_->CreateUnappliedNewBookmarkItemWithParent(
+      "child", DefaultBookmarkSpecifics(), "parent");
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
 
   const sessions::StatusController& status = session()->status_controller();
   EXPECT_EQ(0, status.num_encryption_conflicts())
       << "Simple update shouldn't result in conflicts";
   EXPECT_EQ(0, status.num_hierarchy_conflicts())
       << "Simple update shouldn't result in conflicts";
   EXPECT_EQ(2, status.num_updates_applied())
       << "All items should have been successfully applied";
 }
 
 TEST_F(ApplyUpdatesAndResolveConflictsCommandTest,
        UpdateWithChildrenBeforeParents) {
   // Set a bunch of updates which are difficult to apply in the order
   // they're received due to dependencies on other unseen items.
   string root_server_id = syncable::GetNullId().GetServerId();
-  entry_factory_->CreateUnappliedNewItemWithParent(
+  entry_factory_->CreateUnappliedNewBookmarkItemWithParent(
       "a_child_created_first", DefaultBookmarkSpecifics(), "parent");
-  entry_factory_->CreateUnappliedNewItemWithParent(
+  entry_factory_->CreateUnappliedNewBookmarkItemWithParent(
       "x_child_created_first", DefaultBookmarkSpecifics(), "parent");
-  entry_factory_->CreateUnappliedNewItemWithParent(
+  entry_factory_->CreateUnappliedNewBookmarkItemWithParent(
       "parent", DefaultBookmarkSpecifics(), root_server_id);
-  entry_factory_->CreateUnappliedNewItemWithParent(
+  entry_factory_->CreateUnappliedNewBookmarkItemWithParent(
       "a_child_created_second", DefaultBookmarkSpecifics(), "parent");
-  entry_factory_->CreateUnappliedNewItemWithParent(
+  entry_factory_->CreateUnappliedNewBookmarkItemWithParent(
       "x_child_created_second", DefaultBookmarkSpecifics(), "parent");
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
 
   const sessions::StatusController& status = session()->status_controller();
   EXPECT_EQ(5, status.num_updates_applied())
       << "All updates should have been successfully applied";
 }
 
 // Runs the ApplyUpdatesAndResolveConflictsCommand on an item that has both
 // local and remote modifications (IS_UNSYNCED and IS_UNAPPLIED_UPDATE).  We
 // expect the command to detect that this update can't be applied because it is
 // in a CONFLICT state.
 TEST_F(ApplyUpdatesAndResolveConflictsCommandTest, SimpleConflict) {
-  entry_factory_->CreateUnappliedAndUnsyncedItem("item", BOOKMARKS);
+  entry_factory_->CreateUnappliedAndUnsyncedBookmarkItem("item");
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
 
   const sessions::StatusController& status = session()->status_controller();
   EXPECT_EQ(1, status.num_server_overwrites())
       << "Unsynced and unapplied item conflict should be resolved";
   EXPECT_EQ(0, status.num_updates_applied())
       << "Update should not be applied; we should override the server.";
 }
 
 // Runs the ApplyUpdatesAndResolveConflictsCommand on an item that has both
 // local and remote modifications *and* the remote modification cannot be
 // applied without violating the tree constraints.  We expect the command to
 // detect that this update can't be applied and that this situation can't be
 // resolved with the simple conflict processing logic; it is in a
 // CONFLICT_HIERARCHY state.
 TEST_F(ApplyUpdatesAndResolveConflictsCommandTest, HierarchyAndSimpleConflict) {
   // Create a simply-conflicting item.  It will start with valid parent ids.
-  int64 handle = entry_factory_->CreateUnappliedAndUnsyncedItem(
-      "orphaned_by_server", BOOKMARKS);
+  int64 handle = entry_factory_->CreateUnappliedAndUnsyncedBookmarkItem(
+      "orphaned_by_server");
   {
     // Manually set the SERVER_PARENT_ID to bad value.
     // A bad parent indicates a hierarchy conflict.
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(entry.good());
 
     entry.Put(syncable::SERVER_PARENT_ID,
               TestIdFactory::MakeServer("bogus_parent"));
   }
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
 
   const sessions::StatusController& status = session()->status_controller();
   EXPECT_EQ(1, status.num_hierarchy_conflicts());
 }
 
 
 // Runs the ApplyUpdatesAndResolveConflictsCommand on an item with remote
 // modifications that would create a directory loop if the update were applied.
 // We expect the command to detect that this update can't be applied because it
 // is in a CONFLICT_HIERARCHY state.
 TEST_F(ApplyUpdatesAndResolveConflictsCommandTest,
        HierarchyConflictDirectoryLoop) {
   // Item 'X' locally has parent of 'root'.  Server is updating it to have
   // parent of 'Y'.
   {
     // Create it as a child of root node.
-    int64 handle = entry_factory_->CreateSyncedItem("X", BOOKMARKS, true);
+    int64 handle = entry_factory_->CreateSyncedBookmarkItem("X", true);
 
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(entry.good());
 
     // Re-parent from root to "Y"
     entry.Put(syncable::SERVER_VERSION, entry_factory_->GetNextRevision());
     entry.Put(syncable::IS_UNAPPLIED_UPDATE, true);
     entry.Put(syncable::SERVER_PARENT_ID, TestIdFactory::MakeServer("Y"));
   }
 
   // Item 'Y' is child of 'X'.
-  entry_factory_->CreateUnsyncedItem(
+  entry_factory_->CreateUnsyncedBookmarkItem(
       TestIdFactory::MakeServer("Y"), TestIdFactory::MakeServer("X"), "Y", true,
-      BOOKMARKS, NULL);
+      NULL);
 
   // If the server's update were applied, we would have X be a child of Y, and Y
   // as a child of X.  That's a directory loop.  The UpdateApplicator should
   // prevent the update from being applied and note that this is a hierarchy
   // conflict.
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
 
   const sessions::StatusController& status = session()->status_controller();
 
   // This should count as a hierarchy conflict.
   EXPECT_EQ(1, status.num_hierarchy_conflicts());
 }
 
 // Runs the ApplyUpdatesAndResolveConflictsCommand on a directory where the
 // server sent us an update to add a child to a locally deleted (and unsynced)
 // parent.  We expect the command to not apply the update and to indicate the
 // update is in a CONFLICT_HIERARCHY state.
 TEST_F(ApplyUpdatesAndResolveConflictsCommandTest,
        HierarchyConflictDeletedParent) {
   // Create a locally deleted parent item.
   int64 parent_handle;
-  entry_factory_->CreateUnsyncedItem(
+  entry_factory_->CreateUnsyncedBookmarkItem(
       Id::CreateFromServerId("parent"), TestIdFactory::root(),
-      "parent", true, BOOKMARKS, &parent_handle);
+      "parent", true, &parent_handle);
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, syncable::GET_BY_HANDLE, parent_handle);
     entry.Put(syncable::IS_DEL, true);
   }
 
   // Create an incoming child from the server.
   entry_factory_->CreateUnappliedNewItemWithParent(
       "child", DefaultBookmarkSpecifics(), "parent");
 
@@ skipping 10 matching lines @@
 
 // Runs the ApplyUpdatesAndResolveConflictsCommand on a directory where the
 // server is trying to delete a folder that has a recently added (and unsynced)
 // child.  We expect the command to not apply the update because it is in a
 // CONFLICT_HIERARCHY state.
 TEST_F(ApplyUpdatesAndResolveConflictsCommandTest,
        HierarchyConflictDeleteNonEmptyDirectory) {
   // Create a server-deleted directory.
   {
     // Create it as a child of root node.
-    int64 handle =
-        entry_factory_->CreateSyncedItem("parent", BOOKMARKS, true);
+    int64 handle = entry_factory_->CreateSyncedBookmarkItem("parent", true);
 
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(entry.good());
 
     // Delete it on the server.
     entry.Put(syncable::SERVER_VERSION, entry_factory_->GetNextRevision());
     entry.Put(syncable::IS_UNAPPLIED_UPDATE, true);
     entry.Put(syncable::SERVER_PARENT_ID, TestIdFactory::root());
     entry.Put(syncable::SERVER_IS_DEL, true);
   }
 
   // Create a local child of the server-deleted directory.
-  entry_factory_->CreateUnsyncedItem(
+  entry_factory_->CreateUnsyncedBookmarkItem(
       TestIdFactory::MakeServer("child"), TestIdFactory::MakeServer("parent"),
-      "child", false, BOOKMARKS, NULL);
+      "child", false, NULL);
 
   // The server's request to delete the directory must be ignored, otherwise our
   // unsynced new child would be orphaned.  This is a hierarchy conflict.
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
 
   const sessions::StatusController& status = session()->status_controller();
   // This should count as a hierarchy conflict.
   EXPECT_EQ(1, status.num_hierarchy_conflicts());
@@ skipping 137 matching lines @@
 
   const sessions::StatusController& status = session()->status_controller();
   EXPECT_EQ(1, status.num_encryption_conflicts())
       << "The updates that can't be decrypted should be in encryption "
       << "conflict";
   EXPECT_EQ(1, status.num_updates_applied())
       << "The undecryptable password update shouldn't be applied";
 }
 
 }  // namespace syncer