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_update_handler.h" 6 7 #include "base/compiler_specific.h" 8 #include "base/message_loop/message_loop.h" 9 #include "base/stl_util.h" 10 #include "sync/engine/syncer_proto_util.h" 11 #include "sync/internal_api/public/base/attachment_id_proto.h" 12 #include "sync/internal_api/public/base/model_type.h" 13 #include "sync/internal_api/public/test/test_entry_factory.h" 14 #include "sync/protocol/sync.pb.h" 15 #include "sync/sessions/directory_type_debug_info_emitter.h" 16 #include "sync/sessions/status_controller.h" 17 #include "sync/syncable/directory.h" 18 #include "sync/syncable/entry.h" 19 #include "sync/syncable/mutable_entry.h" 20 #include "sync/syncable/syncable_model_neutral_write_transaction.h" 21 #include "sync/syncable/syncable_proto_util.h" 22 #include "sync/syncable/syncable_read_transaction.h" 23 #include "sync/syncable/syncable_write_transaction.h" 24 #include "sync/test/engine/fake_model_worker.h" 25 #include "sync/test/engine/test_directory_setter_upper.h" 26 #include "sync/test/engine/test_id_factory.h" 27 #include "sync/test/engine/test_syncable_utils.h" 28 #include "testing/gtest/include/gtest/gtest.h" 29 30 namespace syncer { 31 32 using syncable::UNITTEST; 33 34 static const int64 kDefaultVersion = 1000; 35 36 // A test harness for tests that focus on processing updates. 37 // 38 // Update processing is what occurs when we first download updates. It converts 39 // the received protobuf message into information in the syncable::Directory. 40 // Any invalid or redundant updates will be dropped at this point. 41 class DirectoryUpdateHandlerProcessUpdateTest : public ::testing::Test { 42 public: 43 DirectoryUpdateHandlerProcessUpdateTest() 44 : ui_worker_(new FakeModelWorker(GROUP_UI)) { 45 } 46 47 virtual ~DirectoryUpdateHandlerProcessUpdateTest() {} 48 49 virtual void SetUp() OVERRIDE { 50 dir_maker_.SetUp(); 51 } 52 53 virtual void TearDown() OVERRIDE { 54 dir_maker_.TearDown(); 55 } 56 57 syncable::Directory* dir() { 58 return dir_maker_.directory(); 59 } 60 61 protected: 62 scoped_ptr<sync_pb::SyncEntity> CreateUpdate( 63 const std::string& id, 64 const std::string& parent, 65 const ModelType& type); 66 67 // This exists mostly to give tests access to the protected member function. 68 // Warning: This takes the syncable directory lock. 69 void UpdateSyncEntities( 70 DirectoryUpdateHandler* handler, 71 const SyncEntityList& applicable_updates, 72 sessions::StatusController* status); 73 74 // Another function to access private member functions. 75 void UpdateProgressMarkers( 76 DirectoryUpdateHandler* handler, 77 const sync_pb::DataTypeProgressMarker& progress); 78 79 scoped_refptr<FakeModelWorker> ui_worker() { 80 return ui_worker_; 81 } 82 83 bool EntryExists(const std::string& id) { 84 syncable::ReadTransaction trans(FROM_HERE, dir()); 85 syncable::Entry e(&trans, syncable::GET_BY_ID, 86 syncable::Id::CreateFromServerId(id)); 87 return e.good() && !e.GetIsDel(); 88 } 89 90 protected: 91 // Used in the construction of DirectoryTypeDebugInfoEmitters. 92 ObserverList<TypeDebugInfoObserver> type_observers_; 93 94 private: 95 base::MessageLoop loop_; // Needed to initialize the directory. 96 TestDirectorySetterUpper dir_maker_; 97 scoped_refptr<FakeModelWorker> ui_worker_; 98 }; 99 100 scoped_ptr<sync_pb::SyncEntity> 101 DirectoryUpdateHandlerProcessUpdateTest::CreateUpdate( 102 const std::string& id, 103 const std::string& parent, 104 const ModelType& type) { 105 scoped_ptr<sync_pb::SyncEntity> e(new sync_pb::SyncEntity()); 106 e->set_id_string(id); 107 e->set_parent_id_string(parent); 108 e->set_non_unique_name(id); 109 e->set_name(id); 110 e->set_version(kDefaultVersion); 111 AddDefaultFieldValue(type, e->mutable_specifics()); 112 return e.Pass(); 113 } 114 115 void DirectoryUpdateHandlerProcessUpdateTest::UpdateSyncEntities( 116 DirectoryUpdateHandler* handler, 117 const SyncEntityList& applicable_updates, 118 sessions::StatusController* status) { 119 syncable::ModelNeutralWriteTransaction trans(FROM_HERE, UNITTEST, dir()); 120 handler->UpdateSyncEntities(&trans, applicable_updates, status); 121 } 122 123 void DirectoryUpdateHandlerProcessUpdateTest::UpdateProgressMarkers( 124 DirectoryUpdateHandler* handler, 125 const sync_pb::DataTypeProgressMarker& progress) { 126 handler->UpdateProgressMarker(progress); 127 } 128 129 static const char kCacheGuid[] = "IrcjZ2jyzHDV9Io4+zKcXQ=="; 130 131 // Test that the bookmark tag is set on newly downloaded items. 132 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, NewBookmarkTag) { 133 DirectoryTypeDebugInfoEmitter emitter(BOOKMARKS, &type_observers_); 134 DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker(), &emitter); 135 sync_pb::GetUpdatesResponse gu_response; 136 sessions::StatusController status; 137 138 // Add a bookmark item to the update message. 139 std::string root = syncable::GetNullId().GetServerId(); 140 syncable::Id server_id = syncable::Id::CreateFromServerId("b1"); 141 scoped_ptr<sync_pb::SyncEntity> e = 142 CreateUpdate(SyncableIdToProto(server_id), root, BOOKMARKS); 143 e->set_originator_cache_guid( 144 std::string(kCacheGuid, arraysize(kCacheGuid)-1)); 145 syncable::Id client_id = syncable::Id::CreateFromClientString("-2"); 146 e->set_originator_client_item_id(client_id.GetServerId()); 147 e->set_position_in_parent(0); 148 149 // Add it to the applicable updates list. 150 SyncEntityList bookmark_updates; 151 bookmark_updates.push_back(e.get()); 152 153 // Process the update. 154 UpdateSyncEntities(&handler, bookmark_updates, &status); 155 156 syncable::ReadTransaction trans(FROM_HERE, dir()); 157 syncable::Entry entry(&trans, syncable::GET_BY_ID, server_id); 158 ASSERT_TRUE(entry.good()); 159 EXPECT_TRUE(UniquePosition::IsValidSuffix(entry.GetUniqueBookmarkTag())); 160 EXPECT_TRUE(entry.GetServerUniquePosition().IsValid()); 161 162 // If this assertion fails, that might indicate that the algorithm used to 163 // generate bookmark tags has been modified. This could have implications for 164 // bookmark ordering. Please make sure you know what you're doing if you 165 // intend to make such a change. 166 EXPECT_EQ("6wHRAb3kbnXV5GHrejp4/c1y5tw=", entry.GetUniqueBookmarkTag()); 167 } 168 169 // Test the receipt of a type root node. 170 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, 171 ReceiveServerCreatedBookmarkFolders) { 172 DirectoryTypeDebugInfoEmitter emitter(BOOKMARKS, &type_observers_); 173 DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker(), &emitter); 174 sync_pb::GetUpdatesResponse gu_response; 175 sessions::StatusController status; 176 177 // Create an update that mimics the bookmark root. 178 syncable::Id server_id = syncable::Id::CreateFromServerId("xyz"); 179 std::string root = syncable::GetNullId().GetServerId(); 180 scoped_ptr<sync_pb::SyncEntity> e = 181 CreateUpdate(SyncableIdToProto(server_id), root, BOOKMARKS); 182 e->set_server_defined_unique_tag("google_chrome_bookmarks"); 183 e->set_folder(true); 184 185 // Add it to the applicable updates list. 186 SyncEntityList bookmark_updates; 187 bookmark_updates.push_back(e.get()); 188 189 EXPECT_FALSE(SyncerProtoUtil::ShouldMaintainPosition(*e)); 190 191 // Process it. 192 UpdateSyncEntities(&handler, bookmark_updates, &status); 193 194 // Verify the results. 195 syncable::ReadTransaction trans(FROM_HERE, dir()); 196 syncable::Entry entry(&trans, syncable::GET_BY_ID, server_id); 197 ASSERT_TRUE(entry.good()); 198 199 EXPECT_FALSE(entry.ShouldMaintainPosition()); 200 EXPECT_FALSE(entry.GetUniquePosition().IsValid()); 201 EXPECT_FALSE(entry.GetServerUniquePosition().IsValid()); 202 EXPECT_TRUE(entry.GetUniqueBookmarkTag().empty()); 203 } 204 205 // Test the receipt of a non-bookmark item. 206 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, ReceiveNonBookmarkItem) { 207 DirectoryTypeDebugInfoEmitter emitter(AUTOFILL, &type_observers_); 208 DirectoryUpdateHandler handler(dir(), AUTOFILL, ui_worker(), &emitter); 209 sync_pb::GetUpdatesResponse gu_response; 210 sessions::StatusController status; 211 212 std::string root = syncable::GetNullId().GetServerId(); 213 syncable::Id server_id = syncable::Id::CreateFromServerId("xyz"); 214 scoped_ptr<sync_pb::SyncEntity> e = 215 CreateUpdate(SyncableIdToProto(server_id), root, AUTOFILL); 216 e->set_server_defined_unique_tag("9PGRuKdX5sHyGMB17CvYTXuC43I="); 217 218 // Add it to the applicable updates list. 219 SyncEntityList autofill_updates; 220 autofill_updates.push_back(e.get()); 221 222 EXPECT_FALSE(SyncerProtoUtil::ShouldMaintainPosition(*e)); 223 224 // Process it. 225 UpdateSyncEntities(&handler, autofill_updates, &status); 226 227 syncable::ReadTransaction trans(FROM_HERE, dir()); 228 syncable::Entry entry(&trans, syncable::GET_BY_ID, server_id); 229 ASSERT_TRUE(entry.good()); 230 231 EXPECT_FALSE(entry.ShouldMaintainPosition()); 232 EXPECT_FALSE(entry.GetUniquePosition().IsValid()); 233 EXPECT_FALSE(entry.GetServerUniquePosition().IsValid()); 234 EXPECT_TRUE(entry.GetUniqueBookmarkTag().empty()); 235 } 236 237 // Tests the setting of progress markers. 238 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, ProcessNewProgressMarkers) { 239 DirectoryTypeDebugInfoEmitter emitter(BOOKMARKS, &type_observers_); 240 DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker(), &emitter); 241 242 sync_pb::DataTypeProgressMarker progress; 243 progress.set_data_type_id(GetSpecificsFieldNumberFromModelType(BOOKMARKS)); 244 progress.set_token("token"); 245 246 UpdateProgressMarkers(&handler, progress); 247 248 sync_pb::DataTypeProgressMarker saved; 249 dir()->GetDownloadProgress(BOOKMARKS, &saved); 250 251 EXPECT_EQ(progress.token(), saved.token()); 252 EXPECT_EQ(progress.data_type_id(), saved.data_type_id()); 253 } 254 255 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, GarbageCollectionByVersion) { 256 DirectoryTypeDebugInfoEmitter emitter(SYNCED_NOTIFICATIONS, &type_observers_); 257 DirectoryUpdateHandler handler(dir(), SYNCED_NOTIFICATIONS, 258 ui_worker(), &emitter); 259 sessions::StatusController status; 260 261 sync_pb::DataTypeProgressMarker progress; 262 progress.set_data_type_id( 263 GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS)); 264 progress.set_token("token"); 265 progress.mutable_gc_directive()->set_version_watermark(kDefaultVersion + 10); 266 267 sync_pb::DataTypeContext context; 268 context.set_data_type_id( 269 GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS)); 270 context.set_context("context"); 271 context.set_version(1); 272 273 scoped_ptr<sync_pb::SyncEntity> type_root = 274 CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("root")), 275 syncable::GetNullId().GetServerId(), 276 SYNCED_NOTIFICATIONS); 277 type_root->set_server_defined_unique_tag( 278 ModelTypeToRootTag(SYNCED_NOTIFICATIONS)); 279 type_root->set_folder(true); 280 281 scoped_ptr<sync_pb::SyncEntity> e1 = 282 CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("e1")), 283 type_root->id_string(), 284 SYNCED_NOTIFICATIONS); 285 286 scoped_ptr<sync_pb::SyncEntity> e2 = 287 CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("e2")), 288 type_root->id_string(), 289 SYNCED_NOTIFICATIONS); 290 e2->set_version(kDefaultVersion + 100); 291 292 // Add to the applicable updates list. 293 SyncEntityList updates; 294 updates.push_back(type_root.get()); 295 updates.push_back(e1.get()); 296 updates.push_back(e2.get()); 297 298 // Process and apply updates. 299 EXPECT_EQ( 300 SYNCER_OK, 301 handler.ProcessGetUpdatesResponse(progress, context, updates, &status)); 302 handler.ApplyUpdates(&status); 303 304 // Verify none is deleted because they are unapplied during GC. 305 EXPECT_TRUE(EntryExists(type_root->id_string())); 306 EXPECT_TRUE(EntryExists(e1->id_string())); 307 EXPECT_TRUE(EntryExists(e2->id_string())); 308 309 // Process and apply again. Old entry is deleted but not root. 310 progress.mutable_gc_directive()->set_version_watermark(kDefaultVersion + 20); 311 EXPECT_EQ(SYNCER_OK, 312 handler.ProcessGetUpdatesResponse( 313 progress, context, SyncEntityList(), &status)); 314 handler.ApplyUpdates(&status); 315 EXPECT_TRUE(EntryExists(type_root->id_string())); 316 EXPECT_FALSE(EntryExists(e1->id_string())); 317 EXPECT_TRUE(EntryExists(e2->id_string())); 318 } 319 320 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, ContextVersion) { 321 DirectoryTypeDebugInfoEmitter emitter(SYNCED_NOTIFICATIONS, &type_observers_); 322 DirectoryUpdateHandler handler(dir(), SYNCED_NOTIFICATIONS, 323 ui_worker(), &emitter); 324 sessions::StatusController status; 325 int field_number = GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS); 326 327 sync_pb::DataTypeProgressMarker progress; 328 progress.set_data_type_id( 329 GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS)); 330 progress.set_token("token"); 331 332 sync_pb::DataTypeContext old_context; 333 old_context.set_version(1); 334 old_context.set_context("data"); 335 old_context.set_data_type_id(field_number); 336 337 scoped_ptr<sync_pb::SyncEntity> type_root = 338 CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("root")), 339 syncable::GetNullId().GetServerId(), 340 SYNCED_NOTIFICATIONS); 341 type_root->set_server_defined_unique_tag( 342 ModelTypeToRootTag(SYNCED_NOTIFICATIONS)); 343 type_root->set_folder(true); 344 scoped_ptr<sync_pb::SyncEntity> e1 = 345 CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("e1")), 346 type_root->id_string(), 347 SYNCED_NOTIFICATIONS); 348 349 SyncEntityList updates; 350 updates.push_back(type_root.get()); 351 updates.push_back(e1.get()); 352 353 // The first response should be processed fine. 354 EXPECT_EQ(SYNCER_OK, 355 handler.ProcessGetUpdatesResponse( 356 progress, old_context, updates, &status)); 357 handler.ApplyUpdates(&status); 358 359 EXPECT_TRUE(EntryExists(type_root->id_string())); 360 EXPECT_TRUE(EntryExists(e1->id_string())); 361 362 { 363 sync_pb::DataTypeContext dir_context; 364 syncable::ReadTransaction trans(FROM_HERE, dir()); 365 trans.directory()->GetDataTypeContext( 366 &trans, SYNCED_NOTIFICATIONS, &dir_context); 367 EXPECT_EQ(old_context.SerializeAsString(), dir_context.SerializeAsString()); 368 } 369 370 sync_pb::DataTypeContext new_context; 371 new_context.set_version(0); 372 new_context.set_context("old"); 373 new_context.set_data_type_id(field_number); 374 375 scoped_ptr<sync_pb::SyncEntity> e2 = 376 CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("e2")), 377 type_root->id_string(), 378 SYNCED_NOTIFICATIONS); 379 updates.clear(); 380 updates.push_back(e2.get()); 381 382 // The second response, with an old context version, should result in an 383 // error and the updates should be dropped. 384 EXPECT_EQ(DATATYPE_TRIGGERED_RETRY, 385 handler.ProcessGetUpdatesResponse( 386 progress, new_context, updates, &status)); 387 handler.ApplyUpdates(&status); 388 389 EXPECT_FALSE(EntryExists(e2->id_string())); 390 391 { 392 sync_pb::DataTypeContext dir_context; 393 syncable::ReadTransaction trans(FROM_HERE, dir()); 394 trans.directory()->GetDataTypeContext( 395 &trans, SYNCED_NOTIFICATIONS, &dir_context); 396 EXPECT_EQ(old_context.SerializeAsString(), dir_context.SerializeAsString()); 397 } 398 } 399 400 // See that updates containing attachment metadata are applied 401 // (i.e. server_attachment_metadata is copied to attachment_metadata). 402 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, 403 ProcessAndApplyUpdatesWithAttachments) { 404 DirectoryTypeDebugInfoEmitter emitter(ARTICLES, &type_observers_); 405 DirectoryUpdateHandler handler(dir(), ARTICLES, ui_worker(), &emitter); 406 sessions::StatusController status; 407 408 sync_pb::DataTypeProgressMarker progress; 409 progress.set_data_type_id(GetSpecificsFieldNumberFromModelType(ARTICLES)); 410 progress.set_token("token"); 411 progress.mutable_gc_directive()->set_version_watermark(kDefaultVersion + 10); 412 413 sync_pb::DataTypeContext context; 414 context.set_data_type_id(GetSpecificsFieldNumberFromModelType(ARTICLES)); 415 context.set_context("context"); 416 context.set_version(1); 417 418 scoped_ptr<sync_pb::SyncEntity> type_root = 419 CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("root")), 420 syncable::GetNullId().GetServerId(), 421 ARTICLES); 422 type_root->set_server_defined_unique_tag(ModelTypeToRootTag(ARTICLES)); 423 type_root->set_folder(true); 424 425 scoped_ptr<sync_pb::SyncEntity> e1 = 426 CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("e1")), 427 type_root->id_string(), 428 ARTICLES); 429 sync_pb::AttachmentIdProto* attachment_id = e1->add_attachment_id(); 430 *attachment_id = CreateAttachmentIdProto(); 431 432 SyncEntityList updates; 433 updates.push_back(type_root.get()); 434 updates.push_back(e1.get()); 435 436 // Process and apply updates. 437 EXPECT_EQ( 438 SYNCER_OK, 439 handler.ProcessGetUpdatesResponse(progress, context, updates, &status)); 440 handler.ApplyUpdates(&status); 441 442 ASSERT_TRUE(EntryExists(type_root->id_string())); 443 ASSERT_TRUE(EntryExists(e1->id_string())); 444 { 445 syncable::ReadTransaction trans(FROM_HERE, dir()); 446 syncable::Entry e(&trans, 447 syncable::GET_BY_ID, 448 syncable::Id::CreateFromServerId(e1->id_string())); 449 450 // See that the attachment_metadata is correct. 451 sync_pb::AttachmentMetadata attachment_metadata = e.GetAttachmentMetadata(); 452 ASSERT_EQ(1, attachment_metadata.record_size()); 453 ASSERT_EQ(attachment_id->SerializeAsString(), 454 attachment_metadata.record(0).id().SerializeAsString()); 455 ASSERT_TRUE(attachment_metadata.record(0).is_on_server()); 456 457 // See that attachment_metadata and server_attachment_metadata are equal. 458 ASSERT_EQ(attachment_metadata.SerializeAsString(), 459 e.GetServerAttachmentMetadata().SerializeAsString()); 460 } 461 } 462 463 // A test harness for tests that focus on applying updates. 464 // 465 // Update application is performed when we want to take updates that were 466 // previously downloaded, processed, and stored in our syncable::Directory 467 // and use them to update our local state (both the Directory's local state 468 // and the model's local state, though these tests focus only on the Directory's 469 // local state). 470 // 471 // This is kept separate from the update processing test in part for historical 472 // reasons, and in part because these tests may require a bit more infrastrcture 473 // in the future. Update application should happen on a different thread a lot 474 // of the time so these tests may end up requiring more infrastructure than the 475 // update processing tests. Currently, we're bypassing most of those issues by 476 // using FakeModelWorkers, so there's not much difference between the two test 477 // harnesses. 478 class DirectoryUpdateHandlerApplyUpdateTest : public ::testing::Test { 479 public: 480 DirectoryUpdateHandlerApplyUpdateTest() 481 : ui_worker_(new FakeModelWorker(GROUP_UI)), 482 password_worker_(new FakeModelWorker(GROUP_PASSWORD)), 483 passive_worker_(new FakeModelWorker(GROUP_PASSIVE)), 484 bookmarks_emitter_(BOOKMARKS, &type_observers_), 485 passwords_emitter_(PASSWORDS, &type_observers_), 486 articles_emitter_(ARTICLES, &type_observers_), 487 update_handler_map_deleter_(&update_handler_map_) {} 488 489 virtual void SetUp() OVERRIDE { 490 dir_maker_.SetUp(); 491 entry_factory_.reset(new TestEntryFactory(directory())); 492 493 update_handler_map_.insert(std::make_pair( 494 BOOKMARKS, 495 new DirectoryUpdateHandler(directory(), BOOKMARKS, 496 ui_worker_, &bookmarks_emitter_))); 497 update_handler_map_.insert(std::make_pair( 498 PASSWORDS, 499 new DirectoryUpdateHandler(directory(), 500 PASSWORDS, 501 password_worker_, 502 &passwords_emitter_))); 503 update_handler_map_.insert(std::make_pair( 504 ARTICLES, 505 new DirectoryUpdateHandler( 506 directory(), ARTICLES, ui_worker_, &articles_emitter_))); 507 } 508 509 virtual void TearDown() OVERRIDE { 510 dir_maker_.TearDown(); 511 } 512 513 const UpdateCounters& GetBookmarksUpdateCounters() { 514 return bookmarks_emitter_.GetUpdateCounters(); 515 } 516 517 const UpdateCounters& GetPasswordsUpdateCounters() { 518 return passwords_emitter_.GetUpdateCounters(); 519 } 520 521 const UpdateCounters& GetArticlesUpdateCounters() { 522 return articles_emitter_.GetUpdateCounters(); 523 } 524 525 protected: 526 void ApplyBookmarkUpdates(sessions::StatusController* status) { 527 update_handler_map_[BOOKMARKS]->ApplyUpdates(status); 528 } 529 530 void ApplyPasswordUpdates(sessions::StatusController* status) { 531 update_handler_map_[PASSWORDS]->ApplyUpdates(status); 532 } 533 534 void ApplyArticlesUpdates(sessions::StatusController* status) { 535 update_handler_map_[ARTICLES]->ApplyUpdates(status); 536 } 537 538 TestEntryFactory* entry_factory() { 539 return entry_factory_.get(); 540 } 541 542 syncable::Directory* directory() { 543 return dir_maker_.directory(); 544 } 545 546 private: 547 typedef std::map<ModelType, UpdateHandler*> UpdateHandlerMap; 548 549 base::MessageLoop loop_; // Needed to initialize the directory. 550 TestDirectorySetterUpper dir_maker_; 551 scoped_ptr<TestEntryFactory> entry_factory_; 552 553 scoped_refptr<FakeModelWorker> ui_worker_; 554 scoped_refptr<FakeModelWorker> password_worker_; 555 scoped_refptr<FakeModelWorker> passive_worker_; 556 557 ObserverList<TypeDebugInfoObserver> type_observers_; 558 DirectoryTypeDebugInfoEmitter bookmarks_emitter_; 559 DirectoryTypeDebugInfoEmitter passwords_emitter_; 560 DirectoryTypeDebugInfoEmitter articles_emitter_; 561 562 UpdateHandlerMap update_handler_map_; 563 STLValueDeleter<UpdateHandlerMap> update_handler_map_deleter_; 564 }; 565 566 namespace { 567 sync_pb::EntitySpecifics DefaultBookmarkSpecifics() { 568 sync_pb::EntitySpecifics result; 569 AddDefaultFieldValue(BOOKMARKS, &result); 570 return result; 571 } 572 } // namespace 573 574 // Test update application for a few bookmark items. 575 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, SimpleBookmark) { 576 sessions::StatusController status; 577 578 std::string root_server_id = syncable::GetNullId().GetServerId(); 579 int64 parent_handle = 580 entry_factory()->CreateUnappliedNewBookmarkItemWithParent( 581 "parent", DefaultBookmarkSpecifics(), root_server_id); 582 int64 child_handle = 583 entry_factory()->CreateUnappliedNewBookmarkItemWithParent( 584 "child", DefaultBookmarkSpecifics(), "parent"); 585 586 ApplyBookmarkUpdates(&status); 587 588 const UpdateCounters& counter = GetBookmarksUpdateCounters(); 589 EXPECT_EQ(0, counter.num_encryption_conflict_application_failures) 590 << "Simple update shouldn't result in conflicts"; 591 EXPECT_EQ(0, counter.num_hierarchy_conflict_application_failures) 592 << "Simple update shouldn't result in conflicts"; 593 EXPECT_EQ(2, counter.num_updates_applied) 594 << "All items should have been successfully applied"; 595 596 { 597 syncable::ReadTransaction trans(FROM_HERE, directory()); 598 599 syncable::Entry parent(&trans, syncable::GET_BY_HANDLE, parent_handle); 600 syncable::Entry child(&trans, syncable::GET_BY_HANDLE, child_handle); 601 602 ASSERT_TRUE(parent.good()); 603 ASSERT_TRUE(child.good()); 604 605 EXPECT_FALSE(parent.GetIsUnsynced()); 606 EXPECT_FALSE(parent.GetIsUnappliedUpdate()); 607 EXPECT_FALSE(child.GetIsUnsynced()); 608 EXPECT_FALSE(child.GetIsUnappliedUpdate()); 609 } 610 } 611 612 // Test that the applicator can handle updates delivered out of order. 613 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, 614 BookmarkChildrenBeforeParent) { 615 // Start with some bookmarks whose parents are unknown. 616 std::string root_server_id = syncable::GetNullId().GetServerId(); 617 int64 a_handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent( 618 "a_child_created_first", DefaultBookmarkSpecifics(), "parent"); 619 int64 x_handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent( 620 "x_child_created_first", DefaultBookmarkSpecifics(), "parent"); 621 622 // Update application will fail. 623 sessions::StatusController status1; 624 ApplyBookmarkUpdates(&status1); 625 EXPECT_EQ(0, status1.num_updates_applied()); 626 EXPECT_EQ(2, status1.num_hierarchy_conflicts()); 627 628 { 629 syncable::ReadTransaction trans(FROM_HERE, directory()); 630 631 syncable::Entry a(&trans, syncable::GET_BY_HANDLE, a_handle); 632 syncable::Entry x(&trans, syncable::GET_BY_HANDLE, x_handle); 633 634 ASSERT_TRUE(a.good()); 635 ASSERT_TRUE(x.good()); 636 637 EXPECT_TRUE(a.GetIsUnappliedUpdate()); 638 EXPECT_TRUE(x.GetIsUnappliedUpdate()); 639 } 640 641 // Now add their parent and a few siblings. 642 entry_factory()->CreateUnappliedNewBookmarkItemWithParent( 643 "parent", DefaultBookmarkSpecifics(), root_server_id); 644 entry_factory()->CreateUnappliedNewBookmarkItemWithParent( 645 "a_child_created_second", DefaultBookmarkSpecifics(), "parent"); 646 entry_factory()->CreateUnappliedNewBookmarkItemWithParent( 647 "x_child_created_second", DefaultBookmarkSpecifics(), "parent"); 648 649 // Update application will succeed. 650 sessions::StatusController status2; 651 ApplyBookmarkUpdates(&status2); 652 EXPECT_EQ(5, status2.num_updates_applied()) 653 << "All updates should have been successfully applied"; 654 655 { 656 syncable::ReadTransaction trans(FROM_HERE, directory()); 657 658 syncable::Entry a(&trans, syncable::GET_BY_HANDLE, a_handle); 659 syncable::Entry x(&trans, syncable::GET_BY_HANDLE, x_handle); 660 661 ASSERT_TRUE(a.good()); 662 ASSERT_TRUE(x.good()); 663 664 EXPECT_FALSE(a.GetIsUnappliedUpdate()); 665 EXPECT_FALSE(x.GetIsUnappliedUpdate()); 666 } 667 } 668 669 // Try to apply changes on an item that is both IS_UNSYNCED and 670 // IS_UNAPPLIED_UPDATE. Conflict resolution should be performed. 671 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, SimpleBookmarkConflict) { 672 int64 handle = entry_factory()->CreateUnappliedAndUnsyncedBookmarkItem("x"); 673 674 int original_server_version = -10; 675 { 676 syncable::ReadTransaction trans(FROM_HERE, directory()); 677 syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle); 678 original_server_version = e.GetServerVersion(); 679 ASSERT_NE(original_server_version, e.GetBaseVersion()); 680 EXPECT_TRUE(e.GetIsUnsynced()); 681 } 682 683 sessions::StatusController status; 684 ApplyBookmarkUpdates(&status); 685 686 const UpdateCounters& counters = GetBookmarksUpdateCounters(); 687 EXPECT_EQ(1, counters.num_server_overwrites) 688 << "Unsynced and unapplied item conflict should be resolved"; 689 EXPECT_EQ(0, counters.num_updates_applied) 690 << "Update should not be applied; we should override the server."; 691 692 { 693 syncable::ReadTransaction trans(FROM_HERE, directory()); 694 syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle); 695 ASSERT_TRUE(e.good()); 696 EXPECT_EQ(original_server_version, e.GetServerVersion()); 697 EXPECT_EQ(original_server_version, e.GetBaseVersion()); 698 EXPECT_FALSE(e.GetIsUnappliedUpdate()); 699 700 // The unsynced flag will remain set until we successfully commit the item. 701 EXPECT_TRUE(e.GetIsUnsynced()); 702 } 703 } 704 705 // Create a simple conflict that is also a hierarchy conflict. If we were to 706 // follow the normal "server wins" logic, we'd end up violating hierarchy 707 // constraints. The hierarchy conflict must take precedence. We can not allow 708 // the update to be applied. The item must remain in the conflict state. 709 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, HierarchyAndSimpleConflict) { 710 // Create a simply-conflicting item. It will start with valid parent ids. 711 int64 handle = entry_factory()->CreateUnappliedAndUnsyncedBookmarkItem( 712 "orphaned_by_server"); 713 { 714 // Manually set the SERVER_PARENT_ID to bad value. 715 // A bad parent indicates a hierarchy conflict. 716 syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory()); 717 syncable::MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle); 718 ASSERT_TRUE(entry.good()); 719 720 entry.PutServerParentId(TestIdFactory::MakeServer("bogus_parent")); 721 } 722 723 sessions::StatusController status; 724 ApplyBookmarkUpdates(&status); 725 726 const UpdateCounters& counters = GetBookmarksUpdateCounters(); 727 EXPECT_EQ(0, counters.num_updates_applied); 728 EXPECT_EQ(0, counters.num_server_overwrites); 729 EXPECT_EQ(1, counters.num_hierarchy_conflict_application_failures); 730 731 { 732 syncable::ReadTransaction trans(FROM_HERE, directory()); 733 syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle); 734 ASSERT_TRUE(e.good()); 735 EXPECT_TRUE(e.GetIsUnappliedUpdate()); 736 EXPECT_TRUE(e.GetIsUnsynced()); 737 } 738 } 739 740 // Attempt to apply an udpate that would create a bookmark folder loop. This 741 // application should fail. 742 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, BookmarkFolderLoop) { 743 // Item 'X' locally has parent of 'root'. Server is updating it to have 744 // parent of 'Y'. 745 746 // Create it as a child of root node. 747 int64 handle = entry_factory()->CreateSyncedItem("X", BOOKMARKS, true); 748 749 { 750 syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory()); 751 syncable::MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle); 752 ASSERT_TRUE(entry.good()); 753 754 // Re-parent from root to "Y" 755 entry.PutServerVersion(entry_factory()->GetNextRevision()); 756 entry.PutIsUnappliedUpdate(true); 757 entry.PutServerParentId(TestIdFactory::MakeServer("Y")); 758 } 759 760 // Item 'Y' is child of 'X'. 761 entry_factory()->CreateUnsyncedItem( 762 TestIdFactory::MakeServer("Y"), TestIdFactory::MakeServer("X"), "Y", true, 763 BOOKMARKS, NULL); 764 765 // If the server's update were applied, we would have X be a child of Y, and Y 766 // as a child of X. That's a directory loop. The UpdateApplicator should 767 // prevent the update from being applied and note that this is a hierarchy 768 // conflict. 769 770 sessions::StatusController status; 771 ApplyBookmarkUpdates(&status); 772 773 // This should count as a hierarchy conflict. 774 const UpdateCounters& counters = GetBookmarksUpdateCounters(); 775 EXPECT_EQ(1, counters.num_hierarchy_conflict_application_failures); 776 777 { 778 syncable::ReadTransaction trans(FROM_HERE, directory()); 779 syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle); 780 ASSERT_TRUE(e.good()); 781 EXPECT_TRUE(e.GetIsUnappliedUpdate()); 782 EXPECT_FALSE(e.GetIsUnsynced()); 783 } 784 } 785 786 // Test update application where the update has been orphaned by a local folder 787 // deletion. The update application attempt should fail. 788 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, 789 HierarchyConflictDeletedParent) { 790 // Create a locally deleted parent item. 791 int64 parent_handle; 792 entry_factory()->CreateUnsyncedItem( 793 syncable::Id::CreateFromServerId("parent"), TestIdFactory::root(), 794 "parent", true, BOOKMARKS, &parent_handle); 795 { 796 syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory()); 797 syncable::MutableEntry entry(&trans, 798 syncable::GET_BY_HANDLE, 799 parent_handle); 800 entry.PutIsDel(true); 801 } 802 803 // Create an incoming child from the server. 804 int64 child_handle = entry_factory()->CreateUnappliedNewItemWithParent( 805 "child", DefaultBookmarkSpecifics(), "parent"); 806 807 // The server's update may seem valid to some other client, but on this client 808 // that new item's parent no longer exists. The update should not be applied 809 // and the update applicator should indicate this is a hierarchy conflict. 810 811 sessions::StatusController status; 812 ApplyBookmarkUpdates(&status); 813 const UpdateCounters& counters = GetBookmarksUpdateCounters(); 814 EXPECT_EQ(1, counters.num_hierarchy_conflict_application_failures); 815 816 { 817 syncable::ReadTransaction trans(FROM_HERE, directory()); 818 syncable::Entry child(&trans, syncable::GET_BY_HANDLE, child_handle); 819 ASSERT_TRUE(child.good()); 820 EXPECT_TRUE(child.GetIsUnappliedUpdate()); 821 EXPECT_FALSE(child.GetIsUnsynced()); 822 } 823 } 824 825 // Attempt to apply an update that deletes a folder where the folder has 826 // locally-created children. The update application should fail. 827 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, 828 HierarchyConflictDeleteNonEmptyDirectory) { 829 // Create a server-deleted folder as a child of root node. 830 int64 parent_handle = 831 entry_factory()->CreateSyncedItem("parent", BOOKMARKS, true); 832 { 833 syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory()); 834 syncable::MutableEntry entry(&trans, 835 syncable::GET_BY_HANDLE, 836 parent_handle); 837 ASSERT_TRUE(entry.good()); 838 839 // Delete it on the server. 840 entry.PutServerVersion(entry_factory()->GetNextRevision()); 841 entry.PutIsUnappliedUpdate(true); 842 entry.PutServerParentId(TestIdFactory::root()); 843 entry.PutServerIsDel(true); 844 } 845 846 // Create a local child of the server-deleted directory. 847 entry_factory()->CreateUnsyncedItem( 848 TestIdFactory::MakeServer("child"), TestIdFactory::MakeServer("parent"), 849 "child", false, BOOKMARKS, NULL); 850 851 // The server's request to delete the directory must be ignored, otherwise our 852 // unsynced new child would be orphaned. This is a hierarchy conflict. 853 854 sessions::StatusController status; 855 ApplyBookmarkUpdates(&status); 856 857 // This should count as a hierarchy conflict. 858 const UpdateCounters& counters = GetBookmarksUpdateCounters(); 859 EXPECT_EQ(1, counters.num_hierarchy_conflict_application_failures); 860 861 { 862 syncable::ReadTransaction trans(FROM_HERE, directory()); 863 syncable::Entry parent(&trans, syncable::GET_BY_HANDLE, parent_handle); 864 ASSERT_TRUE(parent.good()); 865 EXPECT_TRUE(parent.GetIsUnappliedUpdate()); 866 EXPECT_FALSE(parent.GetIsUnsynced()); 867 } 868 } 869 870 // Attempt to apply updates where the updated item's parent is not known to this 871 // client. The update application attempt should fail. 872 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, 873 HierarchyConflictUnknownParent) { 874 // We shouldn't be able to do anything with either of these items. 875 int64 x_handle = entry_factory()->CreateUnappliedNewItemWithParent( 876 "some_item", DefaultBookmarkSpecifics(), "unknown_parent"); 877 int64 y_handle = entry_factory()->CreateUnappliedNewItemWithParent( 878 "some_other_item", DefaultBookmarkSpecifics(), "some_item"); 879 880 sessions::StatusController status; 881 ApplyBookmarkUpdates(&status); 882 883 const UpdateCounters& counters = GetBookmarksUpdateCounters(); 884 EXPECT_EQ(2, counters.num_hierarchy_conflict_application_failures) 885 << "All updates with an unknown ancestors should be in conflict"; 886 EXPECT_EQ(0, counters.num_updates_applied) 887 << "No item with an unknown ancestor should be applied"; 888 889 { 890 syncable::ReadTransaction trans(FROM_HERE, directory()); 891 syncable::Entry x(&trans, syncable::GET_BY_HANDLE, x_handle); 892 syncable::Entry y(&trans, syncable::GET_BY_HANDLE, y_handle); 893 ASSERT_TRUE(x.good()); 894 ASSERT_TRUE(y.good()); 895 EXPECT_TRUE(x.GetIsUnappliedUpdate()); 896 EXPECT_TRUE(y.GetIsUnappliedUpdate()); 897 EXPECT_FALSE(x.GetIsUnsynced()); 898 EXPECT_FALSE(y.GetIsUnsynced()); 899 } 900 } 901 902 // Attempt application of a mix of items. Some update application attempts will 903 // fail due to hierarchy conflicts. Others should succeed. 904 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, ItemsBothKnownAndUnknown) { 905 // See what happens when there's a mixture of good and bad updates. 906 std::string root_server_id = syncable::GetNullId().GetServerId(); 907 int64 u1_handle = entry_factory()->CreateUnappliedNewItemWithParent( 908 "first_unknown_item", DefaultBookmarkSpecifics(), "unknown_parent"); 909 int64 k1_handle = entry_factory()->CreateUnappliedNewItemWithParent( 910 "first_known_item", DefaultBookmarkSpecifics(), root_server_id); 911 int64 u2_handle = entry_factory()->CreateUnappliedNewItemWithParent( 912 "second_unknown_item", DefaultBookmarkSpecifics(), "unknown_parent"); 913 int64 k2_handle = entry_factory()->CreateUnappliedNewItemWithParent( 914 "second_known_item", DefaultBookmarkSpecifics(), "first_known_item"); 915 int64 k3_handle = entry_factory()->CreateUnappliedNewItemWithParent( 916 "third_known_item", DefaultBookmarkSpecifics(), "fourth_known_item"); 917 int64 k4_handle = entry_factory()->CreateUnappliedNewItemWithParent( 918 "fourth_known_item", DefaultBookmarkSpecifics(), root_server_id); 919 920 sessions::StatusController status; 921 ApplyBookmarkUpdates(&status); 922 923 const UpdateCounters& counters = GetBookmarksUpdateCounters(); 924 EXPECT_EQ(2, counters.num_hierarchy_conflict_application_failures) 925 << "The updates with unknown ancestors should be in conflict"; 926 EXPECT_EQ(4, counters.num_updates_applied) 927 << "The updates with known ancestors should be successfully applied"; 928 929 { 930 syncable::ReadTransaction trans(FROM_HERE, directory()); 931 syncable::Entry u1(&trans, syncable::GET_BY_HANDLE, u1_handle); 932 syncable::Entry u2(&trans, syncable::GET_BY_HANDLE, u2_handle); 933 syncable::Entry k1(&trans, syncable::GET_BY_HANDLE, k1_handle); 934 syncable::Entry k2(&trans, syncable::GET_BY_HANDLE, k2_handle); 935 syncable::Entry k3(&trans, syncable::GET_BY_HANDLE, k3_handle); 936 syncable::Entry k4(&trans, syncable::GET_BY_HANDLE, k4_handle); 937 ASSERT_TRUE(u1.good()); 938 ASSERT_TRUE(u2.good()); 939 ASSERT_TRUE(k1.good()); 940 ASSERT_TRUE(k2.good()); 941 ASSERT_TRUE(k3.good()); 942 ASSERT_TRUE(k4.good()); 943 EXPECT_TRUE(u1.GetIsUnappliedUpdate()); 944 EXPECT_TRUE(u2.GetIsUnappliedUpdate()); 945 EXPECT_FALSE(k1.GetIsUnappliedUpdate()); 946 EXPECT_FALSE(k2.GetIsUnappliedUpdate()); 947 EXPECT_FALSE(k3.GetIsUnappliedUpdate()); 948 EXPECT_FALSE(k4.GetIsUnappliedUpdate()); 949 } 950 } 951 952 // Attempt application of password upates where the passphrase is known. 953 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, DecryptablePassword) { 954 // Decryptable password updates should be applied. 955 Cryptographer* cryptographer; 956 { 957 // Storing the cryptographer separately is bad, but for this test we 958 // know it's safe. 959 syncable::ReadTransaction trans(FROM_HERE, directory()); 960 cryptographer = directory()->GetCryptographer(&trans); 961 } 962 963 KeyParams params = {"localhost", "dummy", "foobar"}; 964 cryptographer->AddKey(params); 965 966 sync_pb::EntitySpecifics specifics; 967 sync_pb::PasswordSpecificsData data; 968 data.set_origin("http://example.com"); 969 970 cryptographer->Encrypt(data, 971 specifics.mutable_password()->mutable_encrypted()); 972 int64 handle = 973 entry_factory()->CreateUnappliedNewItem("item", specifics, false); 974 975 sessions::StatusController status; 976 ApplyPasswordUpdates(&status); 977 978 const UpdateCounters& counters = GetPasswordsUpdateCounters(); 979 EXPECT_EQ(1, counters.num_updates_applied) 980 << "The updates that can be decrypted should be applied"; 981 982 { 983 syncable::ReadTransaction trans(FROM_HERE, directory()); 984 syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle); 985 ASSERT_TRUE(e.good()); 986 EXPECT_FALSE(e.GetIsUnappliedUpdate()); 987 EXPECT_FALSE(e.GetIsUnsynced()); 988 } 989 } 990 991 // Attempt application of encrypted items when the passphrase is not known. 992 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, UndecryptableData) { 993 // Undecryptable updates should not be applied. 994 sync_pb::EntitySpecifics encrypted_bookmark; 995 encrypted_bookmark.mutable_encrypted(); 996 AddDefaultFieldValue(BOOKMARKS, &encrypted_bookmark); 997 std::string root_server_id = syncable::GetNullId().GetServerId(); 998 int64 folder_handle = entry_factory()->CreateUnappliedNewItemWithParent( 999 "folder", 1000 encrypted_bookmark, 1001 root_server_id); 1002 int64 bookmark_handle = entry_factory()->CreateUnappliedNewItem( 1003 "item2", 1004 encrypted_bookmark, 1005 false); 1006 sync_pb::EntitySpecifics encrypted_password; 1007 encrypted_password.mutable_password(); 1008 int64 password_handle = entry_factory()->CreateUnappliedNewItem( 1009 "item3", 1010 encrypted_password, 1011 false); 1012 1013 sessions::StatusController status; 1014 ApplyBookmarkUpdates(&status); 1015 ApplyPasswordUpdates(&status); 1016 1017 const UpdateCounters& bm_counters = GetBookmarksUpdateCounters(); 1018 EXPECT_EQ(2, bm_counters.num_encryption_conflict_application_failures) 1019 << "Updates that can't be decrypted should be in encryption conflict"; 1020 EXPECT_EQ(0, bm_counters.num_updates_applied) 1021 << "No update that can't be decrypted should be applied"; 1022 1023 const UpdateCounters& pw_counters = GetPasswordsUpdateCounters(); 1024 EXPECT_EQ(1, pw_counters.num_encryption_conflict_application_failures) 1025 << "Updates that can't be decrypted should be in encryption conflict"; 1026 EXPECT_EQ(0, pw_counters.num_updates_applied) 1027 << "No update that can't be decrypted should be applied"; 1028 1029 { 1030 syncable::ReadTransaction trans(FROM_HERE, directory()); 1031 syncable::Entry folder(&trans, syncable::GET_BY_HANDLE, folder_handle); 1032 syncable::Entry bm(&trans, syncable::GET_BY_HANDLE, bookmark_handle); 1033 syncable::Entry pw(&trans, syncable::GET_BY_HANDLE, password_handle); 1034 ASSERT_TRUE(folder.good()); 1035 ASSERT_TRUE(bm.good()); 1036 ASSERT_TRUE(pw.good()); 1037 EXPECT_TRUE(folder.GetIsUnappliedUpdate()); 1038 EXPECT_TRUE(bm.GetIsUnappliedUpdate()); 1039 EXPECT_TRUE(pw.GetIsUnappliedUpdate()); 1040 } 1041 } 1042 1043 // Test a mix of decryptable and undecryptable updates. 1044 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, SomeUndecryptablePassword) { 1045 Cryptographer* cryptographer; 1046 1047 int64 decryptable_handle = -1; 1048 int64 undecryptable_handle = -1; 1049 1050 // Only decryptable password updates should be applied. 1051 { 1052 sync_pb::EntitySpecifics specifics; 1053 sync_pb::PasswordSpecificsData data; 1054 data.set_origin("http://example.com/1"); 1055 { 1056 syncable::ReadTransaction trans(FROM_HERE, directory()); 1057 cryptographer = directory()->GetCryptographer(&trans); 1058 1059 KeyParams params = {"localhost", "dummy", "foobar"}; 1060 cryptographer->AddKey(params); 1061 1062 cryptographer->Encrypt(data, 1063 specifics.mutable_password()->mutable_encrypted()); 1064 } 1065 decryptable_handle = 1066 entry_factory()->CreateUnappliedNewItem("item1", specifics, false); 1067 } 1068 { 1069 // Create a new cryptographer, independent of the one in the session. 1070 Cryptographer other_cryptographer(cryptographer->encryptor()); 1071 KeyParams params = {"localhost", "dummy", "bazqux"}; 1072 other_cryptographer.AddKey(params); 1073 1074 sync_pb::EntitySpecifics specifics; 1075 sync_pb::PasswordSpecificsData data; 1076 data.set_origin("http://example.com/2"); 1077 1078 other_cryptographer.Encrypt(data, 1079 specifics.mutable_password()->mutable_encrypted()); 1080 undecryptable_handle = 1081 entry_factory()->CreateUnappliedNewItem("item2", specifics, false); 1082 } 1083 1084 sessions::StatusController status; 1085 ApplyPasswordUpdates(&status); 1086 1087 const UpdateCounters& counters = GetPasswordsUpdateCounters(); 1088 EXPECT_EQ(1, counters.num_encryption_conflict_application_failures) 1089 << "The updates that can't be decrypted should be in encryption " 1090 << "conflict"; 1091 EXPECT_EQ(1, counters.num_updates_applied) 1092 << "The undecryptable password update shouldn't be applied"; 1093 1094 { 1095 syncable::ReadTransaction trans(FROM_HERE, directory()); 1096 syncable::Entry e1(&trans, syncable::GET_BY_HANDLE, decryptable_handle); 1097 syncable::Entry e2(&trans, syncable::GET_BY_HANDLE, undecryptable_handle); 1098 ASSERT_TRUE(e1.good()); 1099 ASSERT_TRUE(e2.good()); 1100 EXPECT_FALSE(e1.GetIsUnappliedUpdate()); 1101 EXPECT_TRUE(e2.GetIsUnappliedUpdate()); 1102 } 1103 } 1104 1105 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, 1106 SimpleConflictDifferentAttachmentMetadata) { 1107 const bool is_folder = false; 1108 sync_pb::EntitySpecifics specifics; 1109 *specifics.mutable_article() = sync_pb::ArticleSpecifics(); 1110 int64 handle = entry_factory()->CreateSyncedItem("art1", ARTICLES, is_folder); 1111 1112 sync_pb::AttachmentIdProto local_attachment_id = CreateAttachmentIdProto(); 1113 sync_pb::AttachmentIdProto server_attachment_id = CreateAttachmentIdProto(); 1114 1115 // Add an attachment to the local attachment metadata. 1116 sync_pb::AttachmentMetadata local_metadata; 1117 sync_pb::AttachmentMetadataRecord* local_record = local_metadata.add_record(); 1118 *local_record->mutable_id() = local_attachment_id; 1119 local_record->set_is_on_server(true); 1120 entry_factory()->SetLocalAttachmentMetadataForItem(handle, local_metadata); 1121 1122 // Add a different attachment to the server attachment metadata. 1123 sync_pb::AttachmentMetadata server_metadata; 1124 sync_pb::AttachmentMetadataRecord* server_record = 1125 server_metadata.add_record(); 1126 *server_record->mutable_id() = server_attachment_id; 1127 server_record->set_is_on_server(true); 1128 entry_factory()->SetServerAttachmentMetadataForItem(handle, server_metadata); 1129 1130 // At this point we have a simple conflict. The server says art1 should have 1131 // server_attachment_id, but the local sync engine says it should have 1132 // local_attachment_id. 1133 1134 sessions::StatusController status; 1135 ApplyArticlesUpdates(&status); 1136 1137 // See that the server won. 1138 const UpdateCounters& counters = GetArticlesUpdateCounters(); 1139 EXPECT_EQ(1, counters.num_updates_applied); 1140 EXPECT_EQ(1, counters.num_local_overwrites); 1141 EXPECT_EQ(0, counters.num_server_overwrites); 1142 local_metadata = entry_factory()->GetLocalAttachmentMetadataForItem(handle); 1143 EXPECT_EQ(server_metadata.SerializeAsString(), 1144 local_metadata.SerializeAsString()); 1145 } 1146 1147 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, 1148 SimpleConflictSameAttachmentMetadataDifferentOrder) { 1149 const bool is_folder = false; 1150 sync_pb::EntitySpecifics specifics; 1151 *specifics.mutable_article() = sync_pb::ArticleSpecifics(); 1152 int64 handle = entry_factory()->CreateSyncedItem("art1", ARTICLES, is_folder); 1153 1154 sync_pb::AttachmentIdProto id1 = CreateAttachmentIdProto(); 1155 sync_pb::AttachmentIdProto id2 = CreateAttachmentIdProto(); 1156 1157 // Add id1, then id2 to the local attachment metadata. 1158 sync_pb::AttachmentMetadata local_metadata; 1159 sync_pb::AttachmentMetadataRecord* record = local_metadata.add_record(); 1160 *record->mutable_id() = id1; 1161 record->set_is_on_server(true); 1162 record = local_metadata.add_record(); 1163 *record->mutable_id() = id2; 1164 record->set_is_on_server(true); 1165 entry_factory()->SetLocalAttachmentMetadataForItem(handle, local_metadata); 1166 1167 // Add id1 and id2 to the server attachment metadata, but in reverse order. 1168 sync_pb::AttachmentMetadata server_metadata; 1169 record = server_metadata.add_record(); 1170 *record->mutable_id() = id2; 1171 record->set_is_on_server(true); 1172 record = local_metadata.add_record(); 1173 *record->mutable_id() = id1; 1174 record->set_is_on_server(true); 1175 entry_factory()->SetServerAttachmentMetadataForItem(handle, server_metadata); 1176 1177 // At this point we have a (false) conflict. 1178 1179 sessions::StatusController status; 1180 ApplyArticlesUpdates(&status); 1181 1182 // See that the server won. 1183 const UpdateCounters& counters = GetArticlesUpdateCounters(); 1184 EXPECT_EQ(1, counters.num_updates_applied); 1185 EXPECT_EQ(1, counters.num_local_overwrites); 1186 EXPECT_EQ(0, counters.num_server_overwrites); 1187 local_metadata = entry_factory()->GetLocalAttachmentMetadataForItem(handle); 1188 EXPECT_EQ(server_metadata.SerializeAsString(), 1189 local_metadata.SerializeAsString()); 1190 } 1191 1192 } // namespace syncer 1193