sync: Initialize entries with a valid model type

sync/engine/apply_updates_and_resolve_conflicts_command_unittest.cc

 // Copyright 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"));
   }
@@ skipping 81 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_->CreateSyncedItem("parent", BOOKMARKS, 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);
@@ skipping 153 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