sync/engine/process_commit_response_command_unittest.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "sync/engine/process_commit_response_command.h"
   6
   7 #include <vector>
   8
   9 #include "base/location.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "sync/internal_api/public/test/test_entry_factory.h"
  12 #include "sync/protocol/bookmark_specifics.pb.h"
  13 #include "sync/protocol/sync.pb.h"
  14 #include "sync/sessions/sync_session.h"
  15 #include "sync/syncable/entry.h"
  16 #include "sync/syncable/mutable_entry.h"
  17 #include "sync/syncable/syncable_id.h"
  18 #include "sync/syncable/syncable_proto_util.h"
  19 #include "sync/syncable/syncable_read_transaction.h"
  20 #include "sync/syncable/syncable_write_transaction.h"
  21 #include "sync/test/engine/fake_model_worker.h"
  22 #include "sync/test/engine/syncer_command_test.h"
  23 #include "sync/test/engine/test_id_factory.h"
  24 #include "testing/gtest/include/gtest/gtest.h"
  25
  26 using std::string;
  27 using sync_pb::ClientToServerMessage;
  28 using sync_pb::CommitResponse;
  29
  30 namespace syncer {
  31
  32 using sessions::SyncSession;
  33 using syncable::BASE_VERSION;
  34 using syncable::Entry;
  35 using syncable::ID;
  36 using syncable::IS_DIR;
  37 using syncable::IS_UNSYNCED;
  38 using syncable::Id;
  39 using syncable::MutableEntry;
  40 using syncable::NON_UNIQUE_NAME;
  41 using syncable::UNIQUE_POSITION;
  42 using syncable::UNITTEST;
  43 using syncable::WriteTransaction;
  44
  45 // A test fixture for tests exercising ProcessCommitResponseCommand.
  46 class ProcessCommitResponseCommandTest : public SyncerCommandTest {
  47  public:
  48   virtual void SetUp() {
  49     workers()->clear();
  50     mutable_routing_info()->clear();
  51
  52     workers()->push_back(
  53         make_scoped_refptr(new FakeModelWorker(GROUP_DB)));
  54     workers()->push_back(
  55         make_scoped_refptr(new FakeModelWorker(GROUP_UI)));
  56     (*mutable_routing_info())[BOOKMARKS] = GROUP_UI;
  57     (*mutable_routing_info())[PREFERENCES] = GROUP_UI;
  58     (*mutable_routing_info())[AUTOFILL] = GROUP_DB;
  59
  60     SyncerCommandTest::SetUp();
  61
  62     test_entry_factory_.reset(new TestEntryFactory(directory()));
  63   }
  64
  65  protected:
  66
  67   ProcessCommitResponseCommandTest()
  68       : next_new_revision_(4000),
  69         next_server_position_(10000) {
  70   }
  71
  72   void CheckEntry(Entry* e, const std::string& name,
  73                   ModelType model_type, const Id& parent_id) {
  74      EXPECT_TRUE(e->good());
  75      ASSERT_EQ(name, e->Get(NON_UNIQUE_NAME));
  76      ASSERT_EQ(model_type, e->GetModelType());
  77      ASSERT_EQ(parent_id, e->Get(syncable::PARENT_ID));
  78      ASSERT_LT(0, e->Get(BASE_VERSION))
  79          << "Item should have a valid (positive) server base revision";
  80   }
  81
  82   // Create a new unsynced item in the database, and synthesize a commit record
  83   // and a commit response for it in the syncer session.  If item_id is a local
  84   // ID, the item will be a create operation.  Otherwise, it will be an edit.
  85   // Returns the metahandle of the newly created item.
  86   int CreateUnprocessedCommitResult(
  87       const Id& item_id,
  88       const Id& parent_id,
  89       const string& name,
  90       bool is_folder,
  91       ModelType model_type,
  92       sessions::OrderedCommitSet *commit_set,
  93       sync_pb::ClientToServerMessage *commit,
  94       sync_pb::ClientToServerResponse *response) {
  95     int64 metahandle = 0;
  96     test_entry_factory_->CreateUnsyncedItem(item_id, parent_id, name,
  97                                             is_folder, model_type, &metahandle);
  98
  99     // ProcessCommitResponseCommand consumes commit_ids from the session
 100     // state, so we need to update that.  O(n^2) because it's a test.
 101     commit_set->AddCommitItem(metahandle, item_id, model_type);
 102
 103     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
 104     MutableEntry entry(&trans, syncable::GET_BY_ID, item_id);
 105     EXPECT_TRUE(entry.good());
 106     entry.Put(syncable::SYNCING, true);
 107
 108     // Add to the commit message.
 109     // TODO(sync): Use the real commit-building code to construct this.
 110     commit->set_message_contents(ClientToServerMessage::COMMIT);
 111     sync_pb::SyncEntity* entity = commit->mutable_commit()->add_entries();
 112     entity->set_non_unique_name(entry.Get(syncable::NON_UNIQUE_NAME));
 113     entity->set_folder(entry.Get(syncable::IS_DIR));
 114     entity->set_parent_id_string(
 115         SyncableIdToProto(entry.Get(syncable::PARENT_ID)));
 116     entity->set_version(entry.Get(syncable::BASE_VERSION));
 117     entity->mutable_specifics()->CopyFrom(entry.Get(syncable::SPECIFICS));
 118     entity->set_id_string(SyncableIdToProto(item_id));
 119
 120     if (!entry.Get(syncable::UNIQUE_CLIENT_TAG).empty()) {
 121       entity->set_client_defined_unique_tag(
 122           entry.Get(syncable::UNIQUE_CLIENT_TAG));
 123     }
 124
 125     // Add to the response message.
 126     response->set_error_code(sync_pb::SyncEnums::SUCCESS);
 127     sync_pb::CommitResponse_EntryResponse* entry_response =
 128         response->mutable_commit()->add_entryresponse();
 129     entry_response->set_response_type(CommitResponse::SUCCESS);
 130     entry_response->set_name("Garbage.");
 131     entry_response->set_non_unique_name(entity->name());
 132     if (item_id.ServerKnows())
 133       entry_response->set_id_string(entity->id_string());
 134     else
 135       entry_response->set_id_string(id_factory_.NewServerId().GetServerId());
 136     entry_response->set_version(next_new_revision_++);
 137
 138     // If the ID of our parent item committed earlier in the batch was
 139     // rewritten, rewrite it in the entry response.  This matches
 140     // the server behavior.
 141     entry_response->set_parent_id_string(entity->parent_id_string());
 142     for (int i = 0; i < commit->commit().entries_size(); ++i) {
 143       if (commit->commit().entries(i).id_string() ==
 144           entity->parent_id_string()) {
 145         entry_response->set_parent_id_string(
 146             response->commit().entryresponse(i).id_string());
 147       }
 148     }
 149
 150     return metahandle;
 151   }
 152
 153   void SetLastErrorCode(sync_pb::CommitResponse::ResponseType error_code,
 154                         sync_pb::ClientToServerResponse* response) {
 155     sync_pb::CommitResponse_EntryResponse* entry_response =
 156         response->mutable_commit()->mutable_entryresponse(
 157             response->mutable_commit()->entryresponse_size() - 1);
 158     entry_response->set_response_type(error_code);
 159   }
 160
 161   TestIdFactory id_factory_;
 162   scoped_ptr<TestEntryFactory> test_entry_factory_;
 163  private:
 164   int64 next_new_revision_;
 165   int64 next_server_position_;
 166   DISALLOW_COPY_AND_ASSIGN(ProcessCommitResponseCommandTest);
 167 };
 168
 169 TEST_F(ProcessCommitResponseCommandTest, MultipleCommitIdProjections) {
 170   sessions::OrderedCommitSet commit_set(session()->context()->routing_info());
 171   sync_pb::ClientToServerMessage request;
 172   sync_pb::ClientToServerResponse response;
 173
 174   Id bookmark_folder_id = id_factory_.NewLocalId();
 175   int bookmark_folder_handle = CreateUnprocessedCommitResult(
 176       bookmark_folder_id, id_factory_.root(), "A bookmark folder", true,
 177       BOOKMARKS, &commit_set, &request, &response);
 178   int bookmark1_handle = CreateUnprocessedCommitResult(
 179       id_factory_.NewLocalId(), bookmark_folder_id, "bookmark 1", false,
 180       BOOKMARKS, &commit_set, &request, &response);
 181   int bookmark2_handle = CreateUnprocessedCommitResult(
 182       id_factory_.NewLocalId(), bookmark_folder_id, "bookmark 2", false,
 183       BOOKMARKS, &commit_set, &request, &response);
 184   int pref1_handle = CreateUnprocessedCommitResult(
 185       id_factory_.NewLocalId(), id_factory_.root(), "Pref 1", false,
 186       PREFERENCES, &commit_set, &request, &response);
 187   int pref2_handle = CreateUnprocessedCommitResult(
 188       id_factory_.NewLocalId(), id_factory_.root(), "Pref 2", false,
 189       PREFERENCES, &commit_set, &request, &response);
 190   int autofill1_handle = CreateUnprocessedCommitResult(
 191       id_factory_.NewLocalId(), id_factory_.root(), "Autofill 1", false,
 192       AUTOFILL, &commit_set, &request, &response);
 193   int autofill2_handle = CreateUnprocessedCommitResult(
 194       id_factory_.NewLocalId(), id_factory_.root(), "Autofill 2", false,
 195       AUTOFILL, &commit_set, &request, &response);
 196
 197   ProcessCommitResponseCommand command(commit_set, request, response);
 198   ExpectGroupsToChange(command, GROUP_UI, GROUP_DB);
 199   command.ExecuteImpl(session());
 200
 201   syncable::ReadTransaction trans(FROM_HERE, directory());
 202
 203   Entry b_folder(&trans, syncable::GET_BY_HANDLE, bookmark_folder_handle);
 204   ASSERT_TRUE(b_folder.good());
 205
 206   Id new_fid = b_folder.Get(syncable::ID);
 207   ASSERT_FALSE(new_fid.IsRoot());
 208   EXPECT_TRUE(new_fid.ServerKnows());
 209   EXPECT_FALSE(bookmark_folder_id.ServerKnows());
 210   EXPECT_FALSE(new_fid == bookmark_folder_id);
 211
 212   ASSERT_EQ("A bookmark folder", b_folder.Get(NON_UNIQUE_NAME))
 213       << "Name of bookmark folder should not change.";
 214   ASSERT_LT(0, b_folder.Get(BASE_VERSION))
 215       << "Bookmark folder should have a valid (positive) server base revision";
 216
 217   // Look at the two bookmarks in bookmark_folder.
 218   Entry b1(&trans, syncable::GET_BY_HANDLE, bookmark1_handle);
 219   Entry b2(&trans, syncable::GET_BY_HANDLE, bookmark2_handle);
 220   CheckEntry(&b1, "bookmark 1", BOOKMARKS, new_fid);
 221   CheckEntry(&b2, "bookmark 2", BOOKMARKS, new_fid);
 222
 223   // Look at the prefs and autofill items.
 224   Entry p1(&trans, syncable::GET_BY_HANDLE, pref1_handle);
 225   Entry p2(&trans, syncable::GET_BY_HANDLE, pref2_handle);
 226   CheckEntry(&p1, "Pref 1", PREFERENCES, id_factory_.root());
 227   CheckEntry(&p2, "Pref 2", PREFERENCES, id_factory_.root());
 228
 229   Entry a1(&trans, syncable::GET_BY_HANDLE, autofill1_handle);
 230   Entry a2(&trans, syncable::GET_BY_HANDLE, autofill2_handle);
 231   CheckEntry(&a1, "Autofill 1", AUTOFILL, id_factory_.root());
 232   CheckEntry(&a2, "Autofill 2", AUTOFILL, id_factory_.root());
 233 }
 234
 235 // In this test, we test processing a commit response for a commit batch that
 236 // includes a newly created folder and some (but not all) of its children.
 237 // In particular, the folder has 50 children, which alternate between being
 238 // new items and preexisting items.  This mixture of new and old is meant to
 239 // be a torture test of the code in ProcessCommitResponseCommand that changes
 240 // an item's ID from a local ID to a server-generated ID on the first commit.
 241 // We commit only the first 25 children in the sibling order, leaving the
 242 // second 25 children as unsynced items.  http://crbug.com/33081 describes
 243 // how this scenario used to fail, reversing the order for the second half
 244 // of the children.
 245 TEST_F(ProcessCommitResponseCommandTest, NewFolderCommitKeepsChildOrder) {
 246   sessions::OrderedCommitSet commit_set(session()->context()->routing_info());
 247   sync_pb::ClientToServerMessage request;
 248   sync_pb::ClientToServerResponse response;
 249
 250   // Create the parent folder, a new item whose ID will change on commit.
 251   Id folder_id = id_factory_.NewLocalId();
 252   CreateUnprocessedCommitResult(folder_id, id_factory_.root(),
 253                                 "A", true, BOOKMARKS,
 254                                 &commit_set, &request, &response);
 255
 256   // Verify that the item is reachable.
 257   {
 258     syncable::ReadTransaction trans(FROM_HERE, directory());
 259     syncable::Entry root(&trans, syncable::GET_BY_ID, id_factory_.root());
 260     ASSERT_TRUE(root.good());
 261     Id child_id = root.GetFirstChildId();
 262     ASSERT_EQ(folder_id, child_id);
 263   }
 264
 265   // The first 25 children of the parent folder will be part of the commit
 266   // batch.  They will be placed left to right in order of creation.
 267   int batch_size = 25;
 268   int i = 0;
 269   Id prev_id = TestIdFactory::root();
 270   for (; i < batch_size; ++i) {
 271     // Alternate between new and old child items, just for kicks.
 272     Id id = (i % 4 < 2) ? id_factory_.NewLocalId() : id_factory_.NewServerId();
 273     int64 handle = CreateUnprocessedCommitResult(
 274         id, folder_id, base::StringPrintf("Item %d", i), false,
 275         BOOKMARKS, &commit_set, &request, &response);
 276     {
 277       syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
 278       syncable::MutableEntry e(&trans, syncable::GET_BY_HANDLE, handle);
 279       ASSERT_TRUE(e.good());
 280       e.PutPredecessor(prev_id);
 281     }
 282     prev_id = id;
 283   }
 284   // The second 25 children will be unsynced items but NOT part of the commit
 285   // batch.  When the ID of the parent folder changes during the commit,
 286   // these items PARENT_ID should be updated, and their ordering should be
 287   // preserved.
 288   for (; i < 2*batch_size; ++i) {
 289     // Alternate between new and old child items, just for kicks.
 290     Id id = (i % 4 < 2) ? id_factory_.NewLocalId() : id_factory_.NewServerId();
 291     int64 handle = -1;
 292     test_entry_factory_->CreateUnsyncedItem(
 293         id, folder_id, base::StringPrintf("Item %d", i),
 294         false, BOOKMARKS, &handle);
 295     {
 296       syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
 297       syncable::MutableEntry e(&trans, syncable::GET_BY_HANDLE, handle);
 298       ASSERT_TRUE(e.good());
 299       e.PutPredecessor(prev_id);
 300     }
 301     prev_id = id;
 302   }
 303
 304   // Process the commit response for the parent folder and the first
 305   // 25 items.  This should apply the values indicated by
 306   // each CommitResponse_EntryResponse to the syncable Entries.  All new
 307   // items in the commit batch should have their IDs changed to server IDs.
 308   ProcessCommitResponseCommand command(commit_set, request, response);
 309   ExpectGroupToChange(command, GROUP_UI);
 310   command.ExecuteImpl(session());
 311
 312   syncable::ReadTransaction trans(FROM_HERE, directory());
 313   // Lookup the parent folder by finding a child of the root.  We can't use
 314   // folder_id here, because it changed during the commit.
 315   syncable::Entry root(&trans, syncable::GET_BY_ID, id_factory_.root());
 316   ASSERT_TRUE(root.good());
 317   Id new_fid = root.GetFirstChildId();
 318   ASSERT_FALSE(new_fid.IsRoot());
 319   EXPECT_TRUE(new_fid.ServerKnows());
 320   EXPECT_FALSE(folder_id.ServerKnows());
 321   EXPECT_TRUE(new_fid != folder_id);
 322   Entry parent(&trans, syncable::GET_BY_ID, new_fid);
 323   ASSERT_TRUE(parent.good());
 324   ASSERT_EQ("A", parent.Get(NON_UNIQUE_NAME))
 325       << "Name of parent folder should not change.";
 326   ASSERT_LT(0, parent.Get(BASE_VERSION))
 327       << "Parent should have a valid (positive) server base revision";
 328
 329   Id cid = parent.GetFirstChildId();
 330
 331   int child_count = 0;
 332   // Now loop over all the children of the parent folder, verifying
 333   // that they are in their original order by checking to see that their
 334   // names are still sequential.
 335   while (!cid.IsRoot()) {
 336     SCOPED_TRACE(::testing::Message("Examining item #") << child_count);
 337     Entry c(&trans, syncable::GET_BY_ID, cid);
 338     DCHECK(c.good());
 339     ASSERT_EQ(base::StringPrintf("Item %d", child_count),
 340               c.Get(NON_UNIQUE_NAME));
 341     ASSERT_EQ(new_fid, c.Get(syncable::PARENT_ID));
 342     if (child_count < batch_size) {
 343       ASSERT_FALSE(c.Get(IS_UNSYNCED)) << "Item should be committed";
 344       ASSERT_TRUE(cid.ServerKnows());
 345       ASSERT_LT(0, c.Get(BASE_VERSION));
 346     } else {
 347       ASSERT_TRUE(c.Get(IS_UNSYNCED)) << "Item should be uncommitted";
 348       // We alternated between creates and edits; double check that these items
 349       // have been preserved.
 350       if (child_count % 4 < 2) {
 351         ASSERT_FALSE(cid.ServerKnows());
 352         ASSERT_GE(0, c.Get(BASE_VERSION));
 353       } else {
 354         ASSERT_TRUE(cid.ServerKnows());
 355         ASSERT_LT(0, c.Get(BASE_VERSION));
 356       }
 357     }
 358     cid = c.GetSuccessorId();
 359     child_count++;
 360   }
 361   ASSERT_EQ(batch_size*2, child_count)
 362       << "Too few or too many children in parent folder after commit.";
 363 }
 364
 365 }  // namespace syncer