src/sync/engine/directory_commit_contribution_unittest.cc

   1 // Copyright 2014 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/directory_commit_contribution.h"
   6
   7 #include "base/message_loop/message_loop.h"
   8 #include "sync/internal_api/public/base/attachment_id_proto.h"
   9 #include "sync/sessions/status_controller.h"
  10 #include "sync/syncable/entry.h"
  11 #include "sync/syncable/mutable_entry.h"
  12 #include "sync/syncable/syncable_read_transaction.h"
  13 #include "sync/syncable/syncable_write_transaction.h"
  14 #include "sync/test/engine/test_directory_setter_upper.h"
  15 #include "sync/test/engine/test_id_factory.h"
  16 #include "sync/test/engine/test_syncable_utils.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18
  19 namespace syncer {
  20
  21 class DirectoryCommitContributionTest : public ::testing::Test {
  22  public:
  23   virtual void SetUp() override {
  24     dir_maker_.SetUp();
  25
  26     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
  27     CreateTypeRoot(&trans, dir(), PREFERENCES);
  28     CreateTypeRoot(&trans, dir(), EXTENSIONS);
  29     CreateTypeRoot(&trans, dir(), ARTICLES);
  30     CreateTypeRoot(&trans, dir(), BOOKMARKS);
  31   }
  32
  33   virtual void TearDown() override {
  34     dir_maker_.TearDown();
  35   }
  36
  37  protected:
  38   int64 CreateUnsyncedItemWithAttachments(
  39       syncable::WriteTransaction* trans,
  40       ModelType type,
  41       const std::string& tag,
  42       const sync_pb::AttachmentMetadata& attachment_metadata) {
  43     syncable::Entry parent_entry(trans, syncable::GET_TYPE_ROOT, type);
  44     syncable::MutableEntry entry(
  45         trans,
  46         syncable::CREATE,
  47         type,
  48         parent_entry.GetId(),
  49         tag);
  50     if (attachment_metadata.record_size() > 0) {
  51       entry.PutAttachmentMetadata(attachment_metadata);
  52     }
  53     entry.PutIsUnsynced(true);
  54     return entry.GetMetahandle();
  55   }
  56
  57   int64 CreateUnsyncedItem(syncable::WriteTransaction* trans,
  58                            ModelType type,
  59                            const std::string& tag) {
  60     return CreateUnsyncedItemWithAttachments(
  61         trans, type, tag, sync_pb::AttachmentMetadata());
  62   }
  63
  64   int64 CreateSyncedItem(syncable::WriteTransaction* trans,
  65                          ModelType type,
  66                          const std::string& tag) {
  67     syncable::Entry parent_entry(trans, syncable::GET_TYPE_ROOT, type);
  68     syncable::MutableEntry entry(
  69         trans,
  70         syncable::CREATE,
  71         type,
  72         parent_entry.GetId(),
  73         tag);
  74
  75     entry.PutId(syncable::Id::CreateFromServerId(
  76         id_factory_.NewServerId().GetServerId()));
  77     entry.PutBaseVersion(10);
  78     entry.PutServerVersion(10);
  79     entry.PutIsUnappliedUpdate(false);
  80     entry.PutIsUnsynced(false);
  81     entry.PutIsDel(false);
  82     entry.PutServerIsDel(false);
  83
  84     return entry.GetMetahandle();
  85   }
  86
  87   void CreateSuccessfulCommitResponse(
  88       const sync_pb::SyncEntity& entity,
  89       sync_pb::CommitResponse::EntryResponse* response) {
  90     response->set_response_type(sync_pb::CommitResponse::SUCCESS);
  91     response->set_non_unique_name(entity.name());
  92     response->set_version(entity.version() + 1);
  93     response->set_parent_id_string(entity.parent_id_string());
  94
  95     if (entity.id_string()[0] == '-')  // Look for the - in 'c-1234' style IDs.
  96       response->set_id_string(id_factory_.NewServerId().GetServerId());
  97     else
  98       response->set_id_string(entity.id_string());
  99   }
 100
 101   syncable::Directory* dir() {
 102     return dir_maker_.directory();
 103   }
 104
 105   TestIdFactory id_factory_;
 106
 107   // Used in construction of DirectoryTypeDebugInfoEmitters.
 108   ObserverList<TypeDebugInfoObserver> type_observers_;
 109
 110  private:
 111   base::MessageLoop loop_;  // Neeed to initialize the directory.
 112   TestDirectorySetterUpper dir_maker_;
 113 };
 114
 115 // Verify that the DirectoryCommitContribution contains only entries of its
 116 // specified type.
 117 TEST_F(DirectoryCommitContributionTest, GatherByTypes) {
 118   int64 pref1;
 119   {
 120     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
 121     pref1 = CreateUnsyncedItem(&trans, PREFERENCES, "pref1");
 122     CreateUnsyncedItem(&trans, PREFERENCES, "pref2");
 123     CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
 124   }
 125
 126   DirectoryTypeDebugInfoEmitter emitter(PREFERENCES, &type_observers_);
 127   scoped_ptr<DirectoryCommitContribution> cc(
 128       DirectoryCommitContribution::Build(dir(), PREFERENCES, 5, &emitter));
 129   ASSERT_EQ(2U, cc->GetNumEntries());
 130
 131   const std::vector<int64>& metahandles = cc->metahandles_;
 132   EXPECT_TRUE(std::find(metahandles.begin(), metahandles.end(), pref1) !=
 133               metahandles.end());
 134   EXPECT_TRUE(std::find(metahandles.begin(), metahandles.end(), pref1) !=
 135               metahandles.end());
 136
 137   cc->CleanUp();
 138 }
 139
 140 // Verify that the DirectoryCommitContributionTest builder function
 141 // truncates if necessary.
 142 TEST_F(DirectoryCommitContributionTest, GatherAndTruncate) {
 143   int64 pref1;
 144   int64 pref2;
 145   {
 146     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
 147     pref1 = CreateUnsyncedItem(&trans, PREFERENCES, "pref1");
 148     pref2 = CreateUnsyncedItem(&trans, PREFERENCES, "pref2");
 149     CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
 150   }
 151
 152   DirectoryTypeDebugInfoEmitter emitter(PREFERENCES, &type_observers_);
 153   scoped_ptr<DirectoryCommitContribution> cc(
 154       DirectoryCommitContribution::Build(dir(), PREFERENCES, 1, &emitter));
 155   ASSERT_EQ(1U, cc->GetNumEntries());
 156
 157   int64 only_metahandle = cc->metahandles_[0];
 158   EXPECT_TRUE(only_metahandle == pref1 || only_metahandle == pref2);
 159
 160   cc->CleanUp();
 161 }
 162
 163 // Sanity check for building commits from DirectoryCommitContributions.
 164 // This test makes two CommitContribution objects of different types and uses
 165 // them to initialize a commit message.  Then it checks that the contents of the
 166 // commit message match those of the directory they came from.
 167 TEST_F(DirectoryCommitContributionTest, PrepareCommit) {
 168   {
 169     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
 170     CreateUnsyncedItem(&trans, PREFERENCES, "pref1");
 171     CreateUnsyncedItem(&trans, PREFERENCES, "pref2");
 172     CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
 173   }
 174
 175   DirectoryTypeDebugInfoEmitter emitter1(PREFERENCES, &type_observers_);
 176   DirectoryTypeDebugInfoEmitter emitter2(EXTENSIONS, &type_observers_);
 177   scoped_ptr<DirectoryCommitContribution> pref_cc(
 178       DirectoryCommitContribution::Build(dir(), PREFERENCES, 25, &emitter1));
 179   scoped_ptr<DirectoryCommitContribution> ext_cc(
 180       DirectoryCommitContribution::Build(dir(), EXTENSIONS, 25, &emitter2));
 181
 182   sync_pb::ClientToServerMessage message;
 183   pref_cc->AddToCommitMessage(&message);
 184   ext_cc->AddToCommitMessage(&message);
 185
 186   const sync_pb::CommitMessage& commit_message = message.commit();
 187
 188   std::set<syncable::Id> ids_for_commit;
 189   ASSERT_EQ(3, commit_message.entries_size());
 190   for (int i = 0; i < commit_message.entries_size(); ++i) {
 191     const sync_pb::SyncEntity& entity = commit_message.entries(i);
 192     // The entities in this test have client-style IDs since they've never been
 193     // committed before, so we must use CreateFromClientString to re-create them
 194     // from the commit message.
 195     ids_for_commit.insert(syncable::Id::CreateFromClientString(
 196             entity.id_string()));
 197   }
 198
 199   ASSERT_EQ(3U, ids_for_commit.size());
 200   {
 201     syncable::ReadTransaction trans(FROM_HERE, dir());
 202     for (std::set<syncable::Id>::iterator it = ids_for_commit.begin();
 203          it != ids_for_commit.end(); ++it) {
 204       SCOPED_TRACE(it->value());
 205       syncable::Entry entry(&trans, syncable::GET_BY_ID, *it);
 206       ASSERT_TRUE(entry.good());
 207       EXPECT_TRUE(entry.GetSyncing());
 208     }
 209   }
 210
 211   pref_cc->CleanUp();
 212   ext_cc->CleanUp();
 213 }
 214
 215 // Check that deletion requests include a model type.
 216 // This was not always the case, but was implemented to allow us to loosen some
 217 // other restrictions in the protocol.
 218 TEST_F(DirectoryCommitContributionTest, DeletedItemsWithSpecifics) {
 219   int64 pref1;
 220   {
 221     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
 222     pref1 = CreateSyncedItem(&trans, PREFERENCES, "pref1");
 223     syncable::MutableEntry e1(&trans, syncable::GET_BY_HANDLE, pref1);
 224     e1.PutIsDel(true);
 225     e1.PutIsUnsynced(true);
 226   }
 227
 228   DirectoryTypeDebugInfoEmitter emitter(PREFERENCES, &type_observers_);
 229   scoped_ptr<DirectoryCommitContribution> pref_cc(
 230       DirectoryCommitContribution::Build(dir(), PREFERENCES, 25, &emitter));
 231   ASSERT_TRUE(pref_cc);
 232
 233   sync_pb::ClientToServerMessage message;
 234   pref_cc->AddToCommitMessage(&message);
 235
 236   const sync_pb::CommitMessage& commit_message = message.commit();
 237   ASSERT_EQ(1, commit_message.entries_size());
 238   EXPECT_TRUE(
 239       commit_message.entries(0).specifics().has_preference());
 240
 241   pref_cc->CleanUp();
 242 }
 243
 244 // As ususal, bookmarks are special.  Bookmark deletion is special.
 245 // Deleted bookmarks include a valid "is folder" bit and their full specifics
 246 // (especially the meta info, which is what server really wants).
 247 TEST_F(DirectoryCommitContributionTest, DeletedBookmarksWithSpecifics) {
 248   int64 bm1;
 249   {
 250     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
 251     bm1 = CreateSyncedItem(&trans, BOOKMARKS, "bm1");
 252     syncable::MutableEntry e1(&trans, syncable::GET_BY_HANDLE, bm1);
 253
 254     e1.PutIsDir(true);
 255     e1.PutServerIsDir(true);
 256
 257     sync_pb::EntitySpecifics specifics;
 258     sync_pb::BookmarkSpecifics* bm_specifics = specifics.mutable_bookmark();
 259     bm_specifics->set_url("http://www.chrome.com");
 260     bm_specifics->set_title("Chrome");
 261     sync_pb::MetaInfo* meta_info = bm_specifics->add_meta_info();
 262     meta_info->set_key("K");
 263     meta_info->set_value("V");
 264     e1.PutSpecifics(specifics);
 265
 266     e1.PutIsDel(true);
 267     e1.PutIsUnsynced(true);
 268   }
 269
 270   DirectoryTypeDebugInfoEmitter emitter(BOOKMARKS, &type_observers_);
 271   scoped_ptr<DirectoryCommitContribution> bm_cc(
 272       DirectoryCommitContribution::Build(dir(), BOOKMARKS, 25, &emitter));
 273   ASSERT_TRUE(bm_cc);
 274
 275   sync_pb::ClientToServerMessage message;
 276   bm_cc->AddToCommitMessage(&message);
 277
 278   const sync_pb::CommitMessage& commit_message = message.commit();
 279   ASSERT_EQ(1, commit_message.entries_size());
 280
 281   const sync_pb::SyncEntity& entity = commit_message.entries(0);
 282   EXPECT_TRUE(entity.has_folder());
 283   ASSERT_TRUE(entity.specifics().has_bookmark());
 284   ASSERT_EQ(1, entity.specifics().bookmark().meta_info_size());
 285   EXPECT_EQ("K", entity.specifics().bookmark().meta_info(0).key());
 286   EXPECT_EQ("V", entity.specifics().bookmark().meta_info(0).value());
 287
 288   bm_cc->CleanUp();
 289 }
 290
 291 // Test that bookmarks support hierarchy.
 292 TEST_F(DirectoryCommitContributionTest, HierarchySupport_Bookmark) {
 293
 294   // Create a normal-looking bookmark item.
 295   int64 bm1;
 296   {
 297     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
 298     bm1 = CreateSyncedItem(&trans, BOOKMARKS, "bm1");
 299     syncable::MutableEntry e(&trans, syncable::GET_BY_HANDLE, bm1);
 300
 301     sync_pb::EntitySpecifics specifics;
 302     sync_pb::BookmarkSpecifics* bm_specifics = specifics.mutable_bookmark();
 303     bm_specifics->set_url("http://www.chrome.com");
 304     bm_specifics->set_title("Chrome");
 305     e.PutSpecifics(specifics);
 306
 307     e.PutIsDel(false);
 308     e.PutIsUnsynced(true);
 309
 310     EXPECT_TRUE(e.ShouldMaintainHierarchy());
 311   }
 312
 313   DirectoryTypeDebugInfoEmitter emitter(BOOKMARKS, &type_observers_);
 314   scoped_ptr<DirectoryCommitContribution> bm_cc(
 315       DirectoryCommitContribution::Build(dir(), BOOKMARKS, 25, &emitter));
 316
 317   sync_pb::ClientToServerMessage message;
 318   bm_cc->AddToCommitMessage(&message);
 319   const sync_pb::CommitMessage& commit_message = message.commit();
 320   bm_cc->CleanUp();
 321
 322   ASSERT_EQ(1, commit_message.entries_size());
 323   EXPECT_TRUE(commit_message.entries(0).has_parent_id_string());
 324   EXPECT_FALSE(commit_message.entries(0).parent_id_string().empty());
 325 }
 326
 327 // Test that preferences do not support hierarchy.
 328 TEST_F(DirectoryCommitContributionTest, HierarchySupport_Preferences) {
 329   // Create a normal-looking prefs item.
 330   int64 pref1;
 331   {
 332     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
 333     pref1 = CreateUnsyncedItem(&trans, PREFERENCES, "pref1");
 334     syncable::MutableEntry e(&trans, syncable::GET_BY_HANDLE, pref1);
 335
 336     EXPECT_FALSE(e.ShouldMaintainHierarchy());
 337   }
 338
 339   DirectoryTypeDebugInfoEmitter emitter(PREFERENCES, &type_observers_);
 340   scoped_ptr<DirectoryCommitContribution> pref_cc(
 341       DirectoryCommitContribution::Build(dir(), PREFERENCES, 25, &emitter));
 342
 343   sync_pb::ClientToServerMessage message;
 344   pref_cc->AddToCommitMessage(&message);
 345   const sync_pb::CommitMessage& commit_message = message.commit();
 346   pref_cc->CleanUp();
 347
 348   ASSERT_EQ(1, commit_message.entries_size());
 349   EXPECT_FALSE(commit_message.entries(0).has_parent_id_string());
 350   EXPECT_TRUE(commit_message.entries(0).parent_id_string().empty());
 351 }
 352
 353 void AddAttachment(sync_pb::AttachmentMetadata* metadata, bool is_on_server) {
 354   sync_pb::AttachmentMetadataRecord record;
 355   *record.mutable_id() = CreateAttachmentIdProto();
 356   record.set_is_on_server(is_on_server);
 357   *metadata->add_record() = record;
 358 }
 359
 360 // Creates some unsynced items, pretends to commit them, and hands back a
 361 // specially crafted response to the syncer in order to test commit response
 362 // processing.  The response simulates a succesful commit scenario.
 363 TEST_F(DirectoryCommitContributionTest, ProcessCommitResponse) {
 364   int64 pref1_handle;
 365   int64 pref2_handle;
 366   int64 ext1_handle;
 367   {
 368     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
 369     pref1_handle = CreateUnsyncedItem(&trans, PREFERENCES, "pref1");
 370     pref2_handle = CreateUnsyncedItem(&trans, PREFERENCES, "pref2");
 371     ext1_handle = CreateUnsyncedItem(&trans, EXTENSIONS, "extension1");
 372   }
 373
 374   DirectoryTypeDebugInfoEmitter emitter1(PREFERENCES, &type_observers_);
 375   DirectoryTypeDebugInfoEmitter emitter2(EXTENSIONS, &type_observers_);
 376   scoped_ptr<DirectoryCommitContribution> pref_cc(
 377       DirectoryCommitContribution::Build(dir(), PREFERENCES, 25, &emitter1));
 378   scoped_ptr<DirectoryCommitContribution> ext_cc(
 379       DirectoryCommitContribution::Build(dir(), EXTENSIONS, 25, &emitter2));
 380
 381   sync_pb::ClientToServerMessage message;
 382   pref_cc->AddToCommitMessage(&message);
 383   ext_cc->AddToCommitMessage(&message);
 384
 385   const sync_pb::CommitMessage& commit_message = message.commit();
 386   ASSERT_EQ(3, commit_message.entries_size());
 387
 388   sync_pb::ClientToServerResponse response;
 389   for (int i = 0; i < commit_message.entries_size(); ++i) {
 390     sync_pb::SyncEntity entity = commit_message.entries(i);
 391     sync_pb::CommitResponse_EntryResponse* entry_response =
 392         response.mutable_commit()->add_entryresponse();
 393     CreateSuccessfulCommitResponse(entity, entry_response);
 394   }
 395
 396   sessions::StatusController status;
 397
 398   // Process these in reverse order.  Just because we can.
 399   ext_cc->ProcessCommitResponse(response, &status);
 400   pref_cc->ProcessCommitResponse(response, &status);
 401
 402   {
 403     syncable::ReadTransaction trans(FROM_HERE, dir());
 404     syncable::Entry p1(&trans, syncable::GET_BY_HANDLE, pref1_handle);
 405     EXPECT_TRUE(p1.GetId().ServerKnows());
 406     EXPECT_FALSE(p1.GetSyncing());
 407     EXPECT_LT(0, p1.GetServerVersion());
 408
 409     syncable::Entry p2(&trans, syncable::GET_BY_HANDLE, pref2_handle);
 410     EXPECT_TRUE(p2.GetId().ServerKnows());
 411     EXPECT_FALSE(p2.GetSyncing());
 412     EXPECT_LT(0, p2.GetServerVersion());
 413
 414     syncable::Entry e1(&trans, syncable::GET_BY_HANDLE, ext1_handle);
 415     EXPECT_TRUE(e1.GetId().ServerKnows());
 416     EXPECT_FALSE(e1.GetSyncing());
 417     EXPECT_LT(0, e1.GetServerVersion());
 418   }
 419
 420   pref_cc->CleanUp();
 421   ext_cc->CleanUp();
 422 }
 423
 424 // Creates some unsynced items with attachments and verifies that only items
 425 // where all attachments have been uploaded to the server are eligible to be
 426 // committed.
 427 TEST_F(DirectoryCommitContributionTest, ProcessCommitResponseWithAttachments) {
 428   int64 art1_handle;
 429   int64 art2_handle;
 430   int64 art3_handle;
 431   {
 432     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
 433
 434     // art1 has two attachments, both have been uploaded to the server.  art1 is
 435     // eligible to be committed.
 436     sync_pb::AttachmentMetadata art1_attachments;
 437     AddAttachment(&art1_attachments, true /* is_on_server */);
 438     AddAttachment(&art1_attachments, true /* is_on_server */);
 439     art1_handle = CreateUnsyncedItemWithAttachments(
 440         &trans, ARTICLES, "art1", art1_attachments);
 441
 442     // art2 has two attachments, one of which has been uploaded to the
 443     // server. art2 is not eligible to be committed.
 444     sync_pb::AttachmentMetadata art2_attachments;
 445     AddAttachment(&art2_attachments, false /* is_on_server */);
 446     AddAttachment(&art2_attachments, true /* is_on_server */);
 447     art2_handle = CreateUnsyncedItemWithAttachments(
 448         &trans, ARTICLES, "art2", art2_attachments);
 449
 450     // art3 has two attachments, neither of which have been uploaded to the
 451     // server. art2 is not eligible to be committed.
 452     sync_pb::AttachmentMetadata art3_attachments;
 453     AddAttachment(&art3_attachments, false /* is_on_server */);
 454     AddAttachment(&art3_attachments, false /* is_on_server */);
 455     art3_handle = CreateUnsyncedItemWithAttachments(
 456         &trans, ARTICLES, "art3", art3_attachments);
 457   }
 458
 459   DirectoryTypeDebugInfoEmitter emitter(ARTICLES, &type_observers_);
 460   scoped_ptr<DirectoryCommitContribution> art_cc(
 461       DirectoryCommitContribution::Build(dir(), ARTICLES, 25, &emitter));
 462
 463   // Only art1 is ready.
 464   EXPECT_EQ(1U, art_cc->GetNumEntries());
 465
 466   sync_pb::ClientToServerMessage message;
 467   art_cc->AddToCommitMessage(&message);
 468
 469   const sync_pb::CommitMessage& commit_message = message.commit();
 470   ASSERT_EQ(1, commit_message.entries_size());
 471
 472   sync_pb::ClientToServerResponse response;
 473   for (int i = 0; i < commit_message.entries_size(); ++i) {
 474     sync_pb::SyncEntity entity = commit_message.entries(i);
 475     sync_pb::CommitResponse_EntryResponse* entry_response =
 476         response.mutable_commit()->add_entryresponse();
 477     CreateSuccessfulCommitResponse(entity, entry_response);
 478   }
 479
 480   sessions::StatusController status;
 481   art_cc->ProcessCommitResponse(response, &status);
 482   {
 483     syncable::ReadTransaction trans(FROM_HERE, dir());
 484
 485     syncable::Entry a1(&trans, syncable::GET_BY_HANDLE, art1_handle);
 486     EXPECT_TRUE(a1.GetId().ServerKnows());
 487     EXPECT_FALSE(a1.GetSyncing());
 488     EXPECT_LT(0, a1.GetServerVersion());
 489
 490     syncable::Entry a2(&trans, syncable::GET_BY_HANDLE, art2_handle);
 491     EXPECT_FALSE(a2.GetId().ServerKnows());
 492     EXPECT_FALSE(a2.GetSyncing());
 493     EXPECT_EQ(0, a2.GetServerVersion());
 494
 495     syncable::Entry a3(&trans, syncable::GET_BY_HANDLE, art3_handle);
 496     EXPECT_FALSE(a3.GetId().ServerKnows());
 497     EXPECT_FALSE(a3.GetSyncing());
 498     EXPECT_EQ(0, a3.GetServerVersion());
 499   }
 500
 501   art_cc->CleanUp();
 502 }
 503
 504 }  // namespace syncer