| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 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/sync_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/model_type.h" | |
| 12 #include "sync/internal_api/public/test/test_entry_factory.h" | |
| 13 #include "sync/protocol/sync.pb.h" | |
| 14 #include "sync/sessions/status_controller.h" | |
| 15 #include "sync/syncable/directory.h" | |
| 16 #include "sync/syncable/entry.h" | |
| 17 #include "sync/syncable/mutable_entry.h" | |
| 18 #include "sync/syncable/syncable_model_neutral_write_transaction.h" | |
| 19 #include "sync/syncable/syncable_proto_util.h" | |
| 20 #include "sync/syncable/syncable_read_transaction.h" | |
| 21 #include "sync/syncable/syncable_write_transaction.h" | |
| 22 #include "sync/test/engine/fake_model_worker.h" | |
| 23 #include "sync/test/engine/test_directory_setter_upper.h" | |
| 24 #include "sync/test/engine/test_id_factory.h" | |
| 25 #include "sync/test/engine/test_syncable_utils.h" | |
| 26 #include "testing/gtest/include/gtest/gtest.h" | |
| 27 | |
| 28 namespace syncer { | |
| 29 | |
| 30 using syncable::UNITTEST; | |
| 31 | |
| 32 // A test harness for tests that focus on processing updates. | |
| 33 // | |
| 34 // Update processing is what occurs when we first download updates. It converts | |
| 35 // the received protobuf message into information in the syncable::Directory. | |
| 36 // Any invalid or redundant updates will be dropped at this point. | |
| 37 class SyncDirectoryUpdateHandlerProcessUpdateTest : public ::testing::Test { | |
| 38 public: | |
| 39 SyncDirectoryUpdateHandlerProcessUpdateTest() | |
| 40 : ui_worker_(new FakeModelWorker(GROUP_UI)) { | |
| 41 } | |
| 42 | |
| 43 virtual ~SyncDirectoryUpdateHandlerProcessUpdateTest() {} | |
| 44 | |
| 45 virtual void SetUp() OVERRIDE { | |
| 46 dir_maker_.SetUp(); | |
| 47 } | |
| 48 | |
| 49 virtual void TearDown() OVERRIDE { | |
| 50 dir_maker_.TearDown(); | |
| 51 } | |
| 52 | |
| 53 syncable::Directory* dir() { | |
| 54 return dir_maker_.directory(); | |
| 55 } | |
| 56 protected: | |
| 57 scoped_ptr<sync_pb::SyncEntity> CreateUpdate( | |
| 58 const std::string& id, | |
| 59 const std::string& parent, | |
| 60 const ModelType& type); | |
| 61 | |
| 62 // This exists mostly to give tests access to the protected member function. | |
| 63 // Warning: This takes the syncable directory lock. | |
| 64 void UpdateSyncEntities( | |
| 65 SyncDirectoryUpdateHandler* handler, | |
| 66 const SyncEntityList& applicable_updates, | |
| 67 sessions::StatusController* status); | |
| 68 | |
| 69 // Another function to access private member functions. | |
| 70 void UpdateProgressMarkers( | |
| 71 SyncDirectoryUpdateHandler* handler, | |
| 72 const sync_pb::DataTypeProgressMarker& progress); | |
| 73 | |
| 74 scoped_refptr<FakeModelWorker> ui_worker() { | |
| 75 return ui_worker_; | |
| 76 } | |
| 77 | |
| 78 private: | |
| 79 base::MessageLoop loop_; // Needed to initialize the directory. | |
| 80 TestDirectorySetterUpper dir_maker_; | |
| 81 scoped_refptr<FakeModelWorker> ui_worker_; | |
| 82 }; | |
| 83 | |
| 84 scoped_ptr<sync_pb::SyncEntity> | |
| 85 SyncDirectoryUpdateHandlerProcessUpdateTest::CreateUpdate( | |
| 86 const std::string& id, | |
| 87 const std::string& parent, | |
| 88 const ModelType& type) { | |
| 89 scoped_ptr<sync_pb::SyncEntity> e(new sync_pb::SyncEntity()); | |
| 90 e->set_id_string(id); | |
| 91 e->set_parent_id_string(parent); | |
| 92 e->set_non_unique_name(id); | |
| 93 e->set_name(id); | |
| 94 e->set_version(1000); | |
| 95 AddDefaultFieldValue(type, e->mutable_specifics()); | |
| 96 return e.Pass(); | |
| 97 } | |
| 98 | |
| 99 void SyncDirectoryUpdateHandlerProcessUpdateTest::UpdateSyncEntities( | |
| 100 SyncDirectoryUpdateHandler* handler, | |
| 101 const SyncEntityList& applicable_updates, | |
| 102 sessions::StatusController* status) { | |
| 103 syncable::ModelNeutralWriteTransaction trans(FROM_HERE, UNITTEST, dir()); | |
| 104 handler->UpdateSyncEntities(&trans, applicable_updates, status); | |
| 105 } | |
| 106 | |
| 107 void SyncDirectoryUpdateHandlerProcessUpdateTest::UpdateProgressMarkers( | |
| 108 SyncDirectoryUpdateHandler* handler, | |
| 109 const sync_pb::DataTypeProgressMarker& progress) { | |
| 110 handler->UpdateProgressMarker(progress); | |
| 111 } | |
| 112 | |
| 113 static const char kCacheGuid[] = "IrcjZ2jyzHDV9Io4+zKcXQ=="; | |
| 114 | |
| 115 // Test that the bookmark tag is set on newly downloaded items. | |
| 116 TEST_F(SyncDirectoryUpdateHandlerProcessUpdateTest, NewBookmarkTag) { | |
| 117 SyncDirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker()); | |
| 118 sync_pb::GetUpdatesResponse gu_response; | |
| 119 sessions::StatusController status; | |
| 120 | |
| 121 // Add a bookmark item to the update message. | |
| 122 std::string root = syncable::GetNullId().GetServerId(); | |
| 123 syncable::Id server_id = syncable::Id::CreateFromServerId("b1"); | |
| 124 scoped_ptr<sync_pb::SyncEntity> e = | |
| 125 CreateUpdate(SyncableIdToProto(server_id), root, BOOKMARKS); | |
| 126 e->set_originator_cache_guid( | |
| 127 std::string(kCacheGuid, arraysize(kCacheGuid)-1)); | |
| 128 syncable::Id client_id = syncable::Id::CreateFromClientString("-2"); | |
| 129 e->set_originator_client_item_id(client_id.GetServerId()); | |
| 130 e->set_position_in_parent(0); | |
| 131 | |
| 132 // Add it to the applicable updates list. | |
| 133 SyncEntityList bookmark_updates; | |
| 134 bookmark_updates.push_back(e.get()); | |
| 135 | |
| 136 // Process the update. | |
| 137 UpdateSyncEntities(&handler, bookmark_updates, &status); | |
| 138 | |
| 139 syncable::ReadTransaction trans(FROM_HERE, dir()); | |
| 140 syncable::Entry entry(&trans, syncable::GET_BY_ID, server_id); | |
| 141 ASSERT_TRUE(entry.good()); | |
| 142 EXPECT_TRUE(UniquePosition::IsValidSuffix(entry.GetUniqueBookmarkTag())); | |
| 143 EXPECT_TRUE(entry.GetServerUniquePosition().IsValid()); | |
| 144 | |
| 145 // If this assertion fails, that might indicate that the algorithm used to | |
| 146 // generate bookmark tags has been modified. This could have implications for | |
| 147 // bookmark ordering. Please make sure you know what you're doing if you | |
| 148 // intend to make such a change. | |
| 149 EXPECT_EQ("6wHRAb3kbnXV5GHrejp4/c1y5tw=", entry.GetUniqueBookmarkTag()); | |
| 150 } | |
| 151 | |
| 152 // Test the receipt of a type root node. | |
| 153 TEST_F(SyncDirectoryUpdateHandlerProcessUpdateTest, | |
| 154 ReceiveServerCreatedBookmarkFolders) { | |
| 155 SyncDirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker()); | |
| 156 sync_pb::GetUpdatesResponse gu_response; | |
| 157 sessions::StatusController status; | |
| 158 | |
| 159 // Create an update that mimics the bookmark root. | |
| 160 syncable::Id server_id = syncable::Id::CreateFromServerId("xyz"); | |
| 161 std::string root = syncable::GetNullId().GetServerId(); | |
| 162 scoped_ptr<sync_pb::SyncEntity> e = | |
| 163 CreateUpdate(SyncableIdToProto(server_id), root, BOOKMARKS); | |
| 164 e->set_server_defined_unique_tag("google_chrome_bookmarks"); | |
| 165 e->set_folder(true); | |
| 166 | |
| 167 // Add it to the applicable updates list. | |
| 168 SyncEntityList bookmark_updates; | |
| 169 bookmark_updates.push_back(e.get()); | |
| 170 | |
| 171 EXPECT_FALSE(SyncerProtoUtil::ShouldMaintainPosition(*e)); | |
| 172 | |
| 173 // Process it. | |
| 174 UpdateSyncEntities(&handler, bookmark_updates, &status); | |
| 175 | |
| 176 // Verify the results. | |
| 177 syncable::ReadTransaction trans(FROM_HERE, dir()); | |
| 178 syncable::Entry entry(&trans, syncable::GET_BY_ID, server_id); | |
| 179 ASSERT_TRUE(entry.good()); | |
| 180 | |
| 181 EXPECT_FALSE(entry.ShouldMaintainPosition()); | |
| 182 EXPECT_FALSE(entry.GetUniquePosition().IsValid()); | |
| 183 EXPECT_FALSE(entry.GetServerUniquePosition().IsValid()); | |
| 184 EXPECT_TRUE(entry.GetUniqueBookmarkTag().empty()); | |
| 185 } | |
| 186 | |
| 187 // Test the receipt of a non-bookmark item. | |
| 188 TEST_F(SyncDirectoryUpdateHandlerProcessUpdateTest, ReceiveNonBookmarkItem) { | |
| 189 SyncDirectoryUpdateHandler handler(dir(), PREFERENCES, ui_worker()); | |
| 190 sync_pb::GetUpdatesResponse gu_response; | |
| 191 sessions::StatusController status; | |
| 192 | |
| 193 std::string root = syncable::GetNullId().GetServerId(); | |
| 194 syncable::Id server_id = syncable::Id::CreateFromServerId("xyz"); | |
| 195 scoped_ptr<sync_pb::SyncEntity> e = | |
| 196 CreateUpdate(SyncableIdToProto(server_id), root, PREFERENCES); | |
| 197 e->set_server_defined_unique_tag("9PGRuKdX5sHyGMB17CvYTXuC43I="); | |
| 198 | |
| 199 // Add it to the applicable updates list. | |
| 200 SyncEntityList autofill_updates; | |
| 201 autofill_updates.push_back(e.get()); | |
| 202 | |
| 203 EXPECT_FALSE(SyncerProtoUtil::ShouldMaintainPosition(*e)); | |
| 204 | |
| 205 // Process it. | |
| 206 UpdateSyncEntities(&handler, autofill_updates, &status); | |
| 207 | |
| 208 syncable::ReadTransaction trans(FROM_HERE, dir()); | |
| 209 syncable::Entry entry(&trans, syncable::GET_BY_ID, server_id); | |
| 210 ASSERT_TRUE(entry.good()); | |
| 211 | |
| 212 EXPECT_FALSE(entry.ShouldMaintainPosition()); | |
| 213 EXPECT_FALSE(entry.GetUniquePosition().IsValid()); | |
| 214 EXPECT_FALSE(entry.GetServerUniquePosition().IsValid()); | |
| 215 EXPECT_TRUE(entry.GetUniqueBookmarkTag().empty()); | |
| 216 } | |
| 217 | |
| 218 // Tests the setting of progress markers. | |
| 219 TEST_F(SyncDirectoryUpdateHandlerProcessUpdateTest, ProcessNewProgressMarkers) { | |
| 220 SyncDirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker()); | |
| 221 | |
| 222 sync_pb::DataTypeProgressMarker progress; | |
| 223 progress.set_data_type_id(GetSpecificsFieldNumberFromModelType(BOOKMARKS)); | |
| 224 progress.set_token("token"); | |
| 225 | |
| 226 UpdateProgressMarkers(&handler, progress); | |
| 227 | |
| 228 sync_pb::DataTypeProgressMarker saved; | |
| 229 dir()->GetDownloadProgress(BOOKMARKS, &saved); | |
| 230 | |
| 231 EXPECT_EQ(progress.token(), saved.token()); | |
| 232 EXPECT_EQ(progress.data_type_id(), saved.data_type_id()); | |
| 233 } | |
| 234 | |
| 235 // A test harness for tests that focus on applying updates. | |
| 236 // | |
| 237 // Update application is performed when we want to take updates that were | |
| 238 // previously downloaded, processed, and stored in our syncable::Directory | |
| 239 // and use them to update our local state (both the Directory's local state | |
| 240 // and the model's local state, though these tests focus only on the Directory's | |
| 241 // local state). | |
| 242 // | |
| 243 // This is kept separate from the update processing test in part for historical | |
| 244 // reasons, and in part because these tests may require a bit more infrastrcture | |
| 245 // in the future. Update application should happen on a different thread a lot | |
| 246 // of the time so these tests may end up requiring more infrastructure than the | |
| 247 // update processing tests. Currently, we're bypassing most of those issues by | |
| 248 // using FakeModelWorkers, so there's not much difference between the two test | |
| 249 // harnesses. | |
| 250 class SyncDirectoryUpdateHandlerApplyUpdateTest : public ::testing::Test { | |
| 251 public: | |
| 252 SyncDirectoryUpdateHandlerApplyUpdateTest() | |
| 253 : ui_worker_(new FakeModelWorker(GROUP_UI)), | |
| 254 password_worker_(new FakeModelWorker(GROUP_PASSWORD)), | |
| 255 passive_worker_(new FakeModelWorker(GROUP_PASSIVE)), | |
| 256 update_handler_map_deleter_(&update_handler_map_) {} | |
| 257 | |
| 258 virtual void SetUp() OVERRIDE { | |
| 259 dir_maker_.SetUp(); | |
| 260 entry_factory_.reset(new TestEntryFactory(directory())); | |
| 261 | |
| 262 update_handler_map_.insert(std::make_pair( | |
| 263 BOOKMARKS, | |
| 264 new SyncDirectoryUpdateHandler(directory(), BOOKMARKS, ui_worker_))); | |
| 265 update_handler_map_.insert(std::make_pair( | |
| 266 PASSWORDS, | |
| 267 new SyncDirectoryUpdateHandler(directory(), | |
| 268 PASSWORDS, | |
| 269 password_worker_))); | |
| 270 } | |
| 271 | |
| 272 virtual void TearDown() OVERRIDE { | |
| 273 dir_maker_.TearDown(); | |
| 274 } | |
| 275 | |
| 276 protected: | |
| 277 void ApplyBookmarkUpdates(sessions::StatusController* status) { | |
| 278 update_handler_map_[BOOKMARKS]->ApplyUpdates(status); | |
| 279 } | |
| 280 | |
| 281 void ApplyPasswordUpdates(sessions::StatusController* status) { | |
| 282 update_handler_map_[PASSWORDS]->ApplyUpdates(status); | |
| 283 } | |
| 284 | |
| 285 TestEntryFactory* entry_factory() { | |
| 286 return entry_factory_.get(); | |
| 287 } | |
| 288 | |
| 289 syncable::Directory* directory() { | |
| 290 return dir_maker_.directory(); | |
| 291 } | |
| 292 | |
| 293 private: | |
| 294 typedef std::map<ModelType, SyncDirectoryUpdateHandler*> UpdateHandlerMap; | |
| 295 | |
| 296 base::MessageLoop loop_; // Needed to initialize the directory. | |
| 297 TestDirectorySetterUpper dir_maker_; | |
| 298 scoped_ptr<TestEntryFactory> entry_factory_; | |
| 299 | |
| 300 scoped_refptr<FakeModelWorker> ui_worker_; | |
| 301 scoped_refptr<FakeModelWorker> password_worker_; | |
| 302 scoped_refptr<FakeModelWorker> passive_worker_; | |
| 303 | |
| 304 UpdateHandlerMap update_handler_map_; | |
| 305 STLValueDeleter<UpdateHandlerMap> update_handler_map_deleter_; | |
| 306 }; | |
| 307 | |
| 308 namespace { | |
| 309 sync_pb::EntitySpecifics DefaultBookmarkSpecifics() { | |
| 310 sync_pb::EntitySpecifics result; | |
| 311 AddDefaultFieldValue(BOOKMARKS, &result); | |
| 312 return result; | |
| 313 } | |
| 314 } // namespace | |
| 315 | |
| 316 // Test update application for a few bookmark items. | |
| 317 TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, SimpleBookmark) { | |
| 318 sessions::StatusController status; | |
| 319 | |
| 320 std::string root_server_id = syncable::GetNullId().GetServerId(); | |
| 321 int64 parent_handle = | |
| 322 entry_factory()->CreateUnappliedNewBookmarkItemWithParent( | |
| 323 "parent", DefaultBookmarkSpecifics(), root_server_id); | |
| 324 int64 child_handle = | |
| 325 entry_factory()->CreateUnappliedNewBookmarkItemWithParent( | |
| 326 "child", DefaultBookmarkSpecifics(), "parent"); | |
| 327 | |
| 328 ApplyBookmarkUpdates(&status); | |
| 329 | |
| 330 EXPECT_EQ(0, status.num_encryption_conflicts()) | |
| 331 << "Simple update shouldn't result in conflicts"; | |
| 332 EXPECT_EQ(0, status.num_hierarchy_conflicts()) | |
| 333 << "Simple update shouldn't result in conflicts"; | |
| 334 EXPECT_EQ(2, status.num_updates_applied()) | |
| 335 << "All items should have been successfully applied"; | |
| 336 | |
| 337 { | |
| 338 syncable::ReadTransaction trans(FROM_HERE, directory()); | |
| 339 | |
| 340 syncable::Entry parent(&trans, syncable::GET_BY_HANDLE, parent_handle); | |
| 341 syncable::Entry child(&trans, syncable::GET_BY_HANDLE, child_handle); | |
| 342 | |
| 343 ASSERT_TRUE(parent.good()); | |
| 344 ASSERT_TRUE(child.good()); | |
| 345 | |
| 346 EXPECT_FALSE(parent.GetIsUnsynced()); | |
| 347 EXPECT_FALSE(parent.GetIsUnappliedUpdate()); | |
| 348 EXPECT_FALSE(child.GetIsUnsynced()); | |
| 349 EXPECT_FALSE(child.GetIsUnappliedUpdate()); | |
| 350 } | |
| 351 } | |
| 352 | |
| 353 // Test that the applicator can handle updates delivered out of order. | |
| 354 TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, | |
| 355 BookmarkChildrenBeforeParent) { | |
| 356 // Start with some bookmarks whose parents are unknown. | |
| 357 std::string root_server_id = syncable::GetNullId().GetServerId(); | |
| 358 int64 a_handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent( | |
| 359 "a_child_created_first", DefaultBookmarkSpecifics(), "parent"); | |
| 360 int64 x_handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent( | |
| 361 "x_child_created_first", DefaultBookmarkSpecifics(), "parent"); | |
| 362 | |
| 363 // Update application will fail. | |
| 364 sessions::StatusController status1; | |
| 365 ApplyBookmarkUpdates(&status1); | |
| 366 EXPECT_EQ(0, status1.num_updates_applied()); | |
| 367 EXPECT_EQ(2, status1.num_hierarchy_conflicts()); | |
| 368 | |
| 369 { | |
| 370 syncable::ReadTransaction trans(FROM_HERE, directory()); | |
| 371 | |
| 372 syncable::Entry a(&trans, syncable::GET_BY_HANDLE, a_handle); | |
| 373 syncable::Entry x(&trans, syncable::GET_BY_HANDLE, x_handle); | |
| 374 | |
| 375 ASSERT_TRUE(a.good()); | |
| 376 ASSERT_TRUE(x.good()); | |
| 377 | |
| 378 EXPECT_TRUE(a.GetIsUnappliedUpdate()); | |
| 379 EXPECT_TRUE(x.GetIsUnappliedUpdate()); | |
| 380 } | |
| 381 | |
| 382 // Now add their parent and a few siblings. | |
| 383 entry_factory()->CreateUnappliedNewBookmarkItemWithParent( | |
| 384 "parent", DefaultBookmarkSpecifics(), root_server_id); | |
| 385 entry_factory()->CreateUnappliedNewBookmarkItemWithParent( | |
| 386 "a_child_created_second", DefaultBookmarkSpecifics(), "parent"); | |
| 387 entry_factory()->CreateUnappliedNewBookmarkItemWithParent( | |
| 388 "x_child_created_second", DefaultBookmarkSpecifics(), "parent"); | |
| 389 | |
| 390 // Update application will succeed. | |
| 391 sessions::StatusController status2; | |
| 392 ApplyBookmarkUpdates(&status2); | |
| 393 EXPECT_EQ(5, status2.num_updates_applied()) | |
| 394 << "All updates should have been successfully applied"; | |
| 395 | |
| 396 { | |
| 397 syncable::ReadTransaction trans(FROM_HERE, directory()); | |
| 398 | |
| 399 syncable::Entry a(&trans, syncable::GET_BY_HANDLE, a_handle); | |
| 400 syncable::Entry x(&trans, syncable::GET_BY_HANDLE, x_handle); | |
| 401 | |
| 402 ASSERT_TRUE(a.good()); | |
| 403 ASSERT_TRUE(x.good()); | |
| 404 | |
| 405 EXPECT_FALSE(a.GetIsUnappliedUpdate()); | |
| 406 EXPECT_FALSE(x.GetIsUnappliedUpdate()); | |
| 407 } | |
| 408 } | |
| 409 | |
| 410 // Try to apply changes on an item that is both IS_UNSYNCED and | |
| 411 // IS_UNAPPLIED_UPDATE. Conflict resolution should be performed. | |
| 412 TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, SimpleBookmarkConflict) { | |
| 413 int64 handle = entry_factory()->CreateUnappliedAndUnsyncedBookmarkItem("x"); | |
| 414 | |
| 415 int original_server_version = -10; | |
| 416 { | |
| 417 syncable::ReadTransaction trans(FROM_HERE, directory()); | |
| 418 syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle); | |
| 419 original_server_version = e.GetServerVersion(); | |
| 420 ASSERT_NE(original_server_version, e.GetBaseVersion()); | |
| 421 EXPECT_TRUE(e.GetIsUnsynced()); | |
| 422 } | |
| 423 | |
| 424 sessions::StatusController status; | |
| 425 ApplyBookmarkUpdates(&status); | |
| 426 EXPECT_EQ(1, status.num_server_overwrites()) | |
| 427 << "Unsynced and unapplied item conflict should be resolved"; | |
| 428 EXPECT_EQ(0, status.num_updates_applied()) | |
| 429 << "Update should not be applied; we should override the server."; | |
| 430 | |
| 431 { | |
| 432 syncable::ReadTransaction trans(FROM_HERE, directory()); | |
| 433 syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle); | |
| 434 ASSERT_TRUE(e.good()); | |
| 435 EXPECT_EQ(original_server_version, e.GetServerVersion()); | |
| 436 EXPECT_EQ(original_server_version, e.GetBaseVersion()); | |
| 437 EXPECT_FALSE(e.GetIsUnappliedUpdate()); | |
| 438 | |
| 439 // The unsynced flag will remain set until we successfully commit the item. | |
| 440 EXPECT_TRUE(e.GetIsUnsynced()); | |
| 441 } | |
| 442 } | |
| 443 | |
| 444 // Create a simple conflict that is also a hierarchy conflict. If we were to | |
| 445 // follow the normal "server wins" logic, we'd end up violating hierarchy | |
| 446 // constraints. The hierarchy conflict must take precedence. We can not allow | |
| 447 // the update to be applied. The item must remain in the conflict state. | |
| 448 TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, HierarchyAndSimpleConflict) { | |
| 449 // Create a simply-conflicting item. It will start with valid parent ids. | |
| 450 int64 handle = entry_factory()->CreateUnappliedAndUnsyncedBookmarkItem( | |
| 451 "orphaned_by_server"); | |
| 452 { | |
| 453 // Manually set the SERVER_PARENT_ID to bad value. | |
| 454 // A bad parent indicates a hierarchy conflict. | |
| 455 syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory()); | |
| 456 syncable::MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle); | |
| 457 ASSERT_TRUE(entry.good()); | |
| 458 | |
| 459 entry.PutServerParentId(TestIdFactory::MakeServer("bogus_parent")); | |
| 460 } | |
| 461 | |
| 462 sessions::StatusController status; | |
| 463 ApplyBookmarkUpdates(&status); | |
| 464 EXPECT_EQ(0, status.num_updates_applied()); | |
| 465 EXPECT_EQ(0, status.num_server_overwrites()); | |
| 466 EXPECT_EQ(1, status.num_hierarchy_conflicts()); | |
| 467 | |
| 468 { | |
| 469 syncable::ReadTransaction trans(FROM_HERE, directory()); | |
| 470 syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle); | |
| 471 ASSERT_TRUE(e.good()); | |
| 472 EXPECT_TRUE(e.GetIsUnappliedUpdate()); | |
| 473 EXPECT_TRUE(e.GetIsUnsynced()); | |
| 474 } | |
| 475 } | |
| 476 | |
| 477 // Attempt to apply an udpate that would create a bookmark folder loop. This | |
| 478 // application should fail. | |
| 479 TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, BookmarkFolderLoop) { | |
| 480 // Item 'X' locally has parent of 'root'. Server is updating it to have | |
| 481 // parent of 'Y'. | |
| 482 | |
| 483 // Create it as a child of root node. | |
| 484 int64 handle = entry_factory()->CreateSyncedItem("X", BOOKMARKS, true); | |
| 485 | |
| 486 { | |
| 487 syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory()); | |
| 488 syncable::MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle); | |
| 489 ASSERT_TRUE(entry.good()); | |
| 490 | |
| 491 // Re-parent from root to "Y" | |
| 492 entry.PutServerVersion(entry_factory()->GetNextRevision()); | |
| 493 entry.PutIsUnappliedUpdate(true); | |
| 494 entry.PutServerParentId(TestIdFactory::MakeServer("Y")); | |
| 495 } | |
| 496 | |
| 497 // Item 'Y' is child of 'X'. | |
| 498 entry_factory()->CreateUnsyncedItem( | |
| 499 TestIdFactory::MakeServer("Y"), TestIdFactory::MakeServer("X"), "Y", true, | |
| 500 BOOKMARKS, NULL); | |
| 501 | |
| 502 // If the server's update were applied, we would have X be a child of Y, and Y | |
| 503 // as a child of X. That's a directory loop. The UpdateApplicator should | |
| 504 // prevent the update from being applied and note that this is a hierarchy | |
| 505 // conflict. | |
| 506 | |
| 507 sessions::StatusController status; | |
| 508 ApplyBookmarkUpdates(&status); | |
| 509 | |
| 510 // This should count as a hierarchy conflict. | |
| 511 EXPECT_EQ(1, status.num_hierarchy_conflicts()); | |
| 512 | |
| 513 { | |
| 514 syncable::ReadTransaction trans(FROM_HERE, directory()); | |
| 515 syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle); | |
| 516 ASSERT_TRUE(e.good()); | |
| 517 EXPECT_TRUE(e.GetIsUnappliedUpdate()); | |
| 518 EXPECT_FALSE(e.GetIsUnsynced()); | |
| 519 } | |
| 520 } | |
| 521 | |
| 522 // Test update application where the update has been orphaned by a local folder | |
| 523 // deletion. The update application attempt should fail. | |
| 524 TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, | |
| 525 HierarchyConflictDeletedParent) { | |
| 526 // Create a locally deleted parent item. | |
| 527 int64 parent_handle; | |
| 528 entry_factory()->CreateUnsyncedItem( | |
| 529 syncable::Id::CreateFromServerId("parent"), TestIdFactory::root(), | |
| 530 "parent", true, BOOKMARKS, &parent_handle); | |
| 531 { | |
| 532 syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory()); | |
| 533 syncable::MutableEntry entry(&trans, | |
| 534 syncable::GET_BY_HANDLE, | |
| 535 parent_handle); | |
| 536 entry.PutIsDel(true); | |
| 537 } | |
| 538 | |
| 539 // Create an incoming child from the server. | |
| 540 int64 child_handle = entry_factory()->CreateUnappliedNewItemWithParent( | |
| 541 "child", DefaultBookmarkSpecifics(), "parent"); | |
| 542 | |
| 543 // The server's update may seem valid to some other client, but on this client | |
| 544 // that new item's parent no longer exists. The update should not be applied | |
| 545 // and the update applicator should indicate this is a hierarchy conflict. | |
| 546 | |
| 547 sessions::StatusController status; | |
| 548 ApplyBookmarkUpdates(&status); | |
| 549 EXPECT_EQ(1, status.num_hierarchy_conflicts()); | |
| 550 | |
| 551 { | |
| 552 syncable::ReadTransaction trans(FROM_HERE, directory()); | |
| 553 syncable::Entry child(&trans, syncable::GET_BY_HANDLE, child_handle); | |
| 554 ASSERT_TRUE(child.good()); | |
| 555 EXPECT_TRUE(child.GetIsUnappliedUpdate()); | |
| 556 EXPECT_FALSE(child.GetIsUnsynced()); | |
| 557 } | |
| 558 } | |
| 559 | |
| 560 // Attempt to apply an update that deletes a folder where the folder has | |
| 561 // locally-created children. The update application should fail. | |
| 562 TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, | |
| 563 HierarchyConflictDeleteNonEmptyDirectory) { | |
| 564 // Create a server-deleted folder as a child of root node. | |
| 565 int64 parent_handle = | |
| 566 entry_factory()->CreateSyncedItem("parent", BOOKMARKS, true); | |
| 567 { | |
| 568 syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory()); | |
| 569 syncable::MutableEntry entry(&trans, | |
| 570 syncable::GET_BY_HANDLE, | |
| 571 parent_handle); | |
| 572 ASSERT_TRUE(entry.good()); | |
| 573 | |
| 574 // Delete it on the server. | |
| 575 entry.PutServerVersion(entry_factory()->GetNextRevision()); | |
| 576 entry.PutIsUnappliedUpdate(true); | |
| 577 entry.PutServerParentId(TestIdFactory::root()); | |
| 578 entry.PutServerIsDel(true); | |
| 579 } | |
| 580 | |
| 581 // Create a local child of the server-deleted directory. | |
| 582 entry_factory()->CreateUnsyncedItem( | |
| 583 TestIdFactory::MakeServer("child"), TestIdFactory::MakeServer("parent"), | |
| 584 "child", false, BOOKMARKS, NULL); | |
| 585 | |
| 586 // The server's request to delete the directory must be ignored, otherwise our | |
| 587 // unsynced new child would be orphaned. This is a hierarchy conflict. | |
| 588 | |
| 589 sessions::StatusController status; | |
| 590 ApplyBookmarkUpdates(&status); | |
| 591 | |
| 592 // This should count as a hierarchy conflict. | |
| 593 EXPECT_EQ(1, status.num_hierarchy_conflicts()); | |
| 594 | |
| 595 { | |
| 596 syncable::ReadTransaction trans(FROM_HERE, directory()); | |
| 597 syncable::Entry parent(&trans, syncable::GET_BY_HANDLE, parent_handle); | |
| 598 ASSERT_TRUE(parent.good()); | |
| 599 EXPECT_TRUE(parent.GetIsUnappliedUpdate()); | |
| 600 EXPECT_FALSE(parent.GetIsUnsynced()); | |
| 601 } | |
| 602 } | |
| 603 | |
| 604 // Attempt to apply updates where the updated item's parent is not known to this | |
| 605 // client. The update application attempt should fail. | |
| 606 TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, | |
| 607 HierarchyConflictUnknownParent) { | |
| 608 // We shouldn't be able to do anything with either of these items. | |
| 609 int64 x_handle = entry_factory()->CreateUnappliedNewItemWithParent( | |
| 610 "some_item", DefaultBookmarkSpecifics(), "unknown_parent"); | |
| 611 int64 y_handle = entry_factory()->CreateUnappliedNewItemWithParent( | |
| 612 "some_other_item", DefaultBookmarkSpecifics(), "some_item"); | |
| 613 | |
| 614 sessions::StatusController status; | |
| 615 ApplyBookmarkUpdates(&status); | |
| 616 | |
| 617 EXPECT_EQ(2, status.num_hierarchy_conflicts()) | |
| 618 << "All updates with an unknown ancestors should be in conflict"; | |
| 619 EXPECT_EQ(0, status.num_updates_applied()) | |
| 620 << "No item with an unknown ancestor should be applied"; | |
| 621 | |
| 622 { | |
| 623 syncable::ReadTransaction trans(FROM_HERE, directory()); | |
| 624 syncable::Entry x(&trans, syncable::GET_BY_HANDLE, x_handle); | |
| 625 syncable::Entry y(&trans, syncable::GET_BY_HANDLE, y_handle); | |
| 626 ASSERT_TRUE(x.good()); | |
| 627 ASSERT_TRUE(y.good()); | |
| 628 EXPECT_TRUE(x.GetIsUnappliedUpdate()); | |
| 629 EXPECT_TRUE(y.GetIsUnappliedUpdate()); | |
| 630 EXPECT_FALSE(x.GetIsUnsynced()); | |
| 631 EXPECT_FALSE(y.GetIsUnsynced()); | |
| 632 } | |
| 633 } | |
| 634 | |
| 635 // Attempt application of a mix of items. Some update application attempts will | |
| 636 // fail due to hierarchy conflicts. Others should succeed. | |
| 637 TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, ItemsBothKnownAndUnknown) { | |
| 638 // See what happens when there's a mixture of good and bad updates. | |
| 639 std::string root_server_id = syncable::GetNullId().GetServerId(); | |
| 640 int64 u1_handle = entry_factory()->CreateUnappliedNewItemWithParent( | |
| 641 "first_unknown_item", DefaultBookmarkSpecifics(), "unknown_parent"); | |
| 642 int64 k1_handle = entry_factory()->CreateUnappliedNewItemWithParent( | |
| 643 "first_known_item", DefaultBookmarkSpecifics(), root_server_id); | |
| 644 int64 u2_handle = entry_factory()->CreateUnappliedNewItemWithParent( | |
| 645 "second_unknown_item", DefaultBookmarkSpecifics(), "unknown_parent"); | |
| 646 int64 k2_handle = entry_factory()->CreateUnappliedNewItemWithParent( | |
| 647 "second_known_item", DefaultBookmarkSpecifics(), "first_known_item"); | |
| 648 int64 k3_handle = entry_factory()->CreateUnappliedNewItemWithParent( | |
| 649 "third_known_item", DefaultBookmarkSpecifics(), "fourth_known_item"); | |
| 650 int64 k4_handle = entry_factory()->CreateUnappliedNewItemWithParent( | |
| 651 "fourth_known_item", DefaultBookmarkSpecifics(), root_server_id); | |
| 652 | |
| 653 sessions::StatusController status; | |
| 654 ApplyBookmarkUpdates(&status); | |
| 655 | |
| 656 EXPECT_EQ(2, status.num_hierarchy_conflicts()) | |
| 657 << "The updates with unknown ancestors should be in conflict"; | |
| 658 EXPECT_EQ(4, status.num_updates_applied()) | |
| 659 << "The updates with known ancestors should be successfully applied"; | |
| 660 | |
| 661 { | |
| 662 syncable::ReadTransaction trans(FROM_HERE, directory()); | |
| 663 syncable::Entry u1(&trans, syncable::GET_BY_HANDLE, u1_handle); | |
| 664 syncable::Entry u2(&trans, syncable::GET_BY_HANDLE, u2_handle); | |
| 665 syncable::Entry k1(&trans, syncable::GET_BY_HANDLE, k1_handle); | |
| 666 syncable::Entry k2(&trans, syncable::GET_BY_HANDLE, k2_handle); | |
| 667 syncable::Entry k3(&trans, syncable::GET_BY_HANDLE, k3_handle); | |
| 668 syncable::Entry k4(&trans, syncable::GET_BY_HANDLE, k4_handle); | |
| 669 ASSERT_TRUE(u1.good()); | |
| 670 ASSERT_TRUE(u2.good()); | |
| 671 ASSERT_TRUE(k1.good()); | |
| 672 ASSERT_TRUE(k2.good()); | |
| 673 ASSERT_TRUE(k3.good()); | |
| 674 ASSERT_TRUE(k4.good()); | |
| 675 EXPECT_TRUE(u1.GetIsUnappliedUpdate()); | |
| 676 EXPECT_TRUE(u2.GetIsUnappliedUpdate()); | |
| 677 EXPECT_FALSE(k1.GetIsUnappliedUpdate()); | |
| 678 EXPECT_FALSE(k2.GetIsUnappliedUpdate()); | |
| 679 EXPECT_FALSE(k3.GetIsUnappliedUpdate()); | |
| 680 EXPECT_FALSE(k4.GetIsUnappliedUpdate()); | |
| 681 } | |
| 682 } | |
| 683 | |
| 684 // Attempt application of password upates where the passphrase is known. | |
| 685 TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, DecryptablePassword) { | |
| 686 // Decryptable password updates should be applied. | |
| 687 Cryptographer* cryptographer; | |
| 688 { | |
| 689 // Storing the cryptographer separately is bad, but for this test we | |
| 690 // know it's safe. | |
| 691 syncable::ReadTransaction trans(FROM_HERE, directory()); | |
| 692 cryptographer = directory()->GetCryptographer(&trans); | |
| 693 } | |
| 694 | |
| 695 KeyParams params = {"localhost", "dummy", "foobar"}; | |
| 696 cryptographer->AddKey(params); | |
| 697 | |
| 698 sync_pb::EntitySpecifics specifics; | |
| 699 sync_pb::PasswordSpecificsData data; | |
| 700 data.set_origin("http://example.com"); | |
| 701 | |
| 702 cryptographer->Encrypt(data, | |
| 703 specifics.mutable_password()->mutable_encrypted()); | |
| 704 int64 handle = | |
| 705 entry_factory()->CreateUnappliedNewItem("item", specifics, false); | |
| 706 | |
| 707 sessions::StatusController status; | |
| 708 ApplyPasswordUpdates(&status); | |
| 709 | |
| 710 EXPECT_EQ(1, status.num_updates_applied()) | |
| 711 << "The updates that can be decrypted should be applied"; | |
| 712 | |
| 713 { | |
| 714 syncable::ReadTransaction trans(FROM_HERE, directory()); | |
| 715 syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle); | |
| 716 ASSERT_TRUE(e.good()); | |
| 717 EXPECT_FALSE(e.GetIsUnappliedUpdate()); | |
| 718 EXPECT_FALSE(e.GetIsUnsynced()); | |
| 719 } | |
| 720 } | |
| 721 | |
| 722 // Attempt application of encrypted items when the passphrase is not known. | |
| 723 TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, UndecryptableData) { | |
| 724 // Undecryptable updates should not be applied. | |
| 725 sync_pb::EntitySpecifics encrypted_bookmark; | |
| 726 encrypted_bookmark.mutable_encrypted(); | |
| 727 AddDefaultFieldValue(BOOKMARKS, &encrypted_bookmark); | |
| 728 std::string root_server_id = syncable::GetNullId().GetServerId(); | |
| 729 int64 folder_handle = entry_factory()->CreateUnappliedNewItemWithParent( | |
| 730 "folder", | |
| 731 encrypted_bookmark, | |
| 732 root_server_id); | |
| 733 int64 bookmark_handle = entry_factory()->CreateUnappliedNewItem( | |
| 734 "item2", | |
| 735 encrypted_bookmark, | |
| 736 false); | |
| 737 sync_pb::EntitySpecifics encrypted_password; | |
| 738 encrypted_password.mutable_password(); | |
| 739 int64 password_handle = entry_factory()->CreateUnappliedNewItem( | |
| 740 "item3", | |
| 741 encrypted_password, | |
| 742 false); | |
| 743 | |
| 744 sessions::StatusController status; | |
| 745 ApplyBookmarkUpdates(&status); | |
| 746 ApplyPasswordUpdates(&status); | |
| 747 | |
| 748 EXPECT_EQ(3, status.num_encryption_conflicts()) | |
| 749 << "Updates that can't be decrypted should be in encryption conflict"; | |
| 750 EXPECT_EQ(0, status.num_updates_applied()) | |
| 751 << "No update that can't be decrypted should be applied"; | |
| 752 | |
| 753 { | |
| 754 syncable::ReadTransaction trans(FROM_HERE, directory()); | |
| 755 syncable::Entry folder(&trans, syncable::GET_BY_HANDLE, folder_handle); | |
| 756 syncable::Entry bm(&trans, syncable::GET_BY_HANDLE, bookmark_handle); | |
| 757 syncable::Entry pw(&trans, syncable::GET_BY_HANDLE, password_handle); | |
| 758 ASSERT_TRUE(folder.good()); | |
| 759 ASSERT_TRUE(bm.good()); | |
| 760 ASSERT_TRUE(pw.good()); | |
| 761 EXPECT_TRUE(folder.GetIsUnappliedUpdate()); | |
| 762 EXPECT_TRUE(bm.GetIsUnappliedUpdate()); | |
| 763 EXPECT_TRUE(pw.GetIsUnappliedUpdate()); | |
| 764 } | |
| 765 } | |
| 766 | |
| 767 // Test a mix of decryptable and undecryptable updates. | |
| 768 TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, SomeUndecryptablePassword) { | |
| 769 Cryptographer* cryptographer; | |
| 770 | |
| 771 int64 decryptable_handle = -1; | |
| 772 int64 undecryptable_handle = -1; | |
| 773 | |
| 774 // Only decryptable password updates should be applied. | |
| 775 { | |
| 776 sync_pb::EntitySpecifics specifics; | |
| 777 sync_pb::PasswordSpecificsData data; | |
| 778 data.set_origin("http://example.com/1"); | |
| 779 { | |
| 780 syncable::ReadTransaction trans(FROM_HERE, directory()); | |
| 781 cryptographer = directory()->GetCryptographer(&trans); | |
| 782 | |
| 783 KeyParams params = {"localhost", "dummy", "foobar"}; | |
| 784 cryptographer->AddKey(params); | |
| 785 | |
| 786 cryptographer->Encrypt(data, | |
| 787 specifics.mutable_password()->mutable_encrypted()); | |
| 788 } | |
| 789 decryptable_handle = | |
| 790 entry_factory()->CreateUnappliedNewItem("item1", specifics, false); | |
| 791 } | |
| 792 { | |
| 793 // Create a new cryptographer, independent of the one in the session. | |
| 794 Cryptographer other_cryptographer(cryptographer->encryptor()); | |
| 795 KeyParams params = {"localhost", "dummy", "bazqux"}; | |
| 796 other_cryptographer.AddKey(params); | |
| 797 | |
| 798 sync_pb::EntitySpecifics specifics; | |
| 799 sync_pb::PasswordSpecificsData data; | |
| 800 data.set_origin("http://example.com/2"); | |
| 801 | |
| 802 other_cryptographer.Encrypt(data, | |
| 803 specifics.mutable_password()->mutable_encrypted()); | |
| 804 undecryptable_handle = | |
| 805 entry_factory()->CreateUnappliedNewItem("item2", specifics, false); | |
| 806 } | |
| 807 | |
| 808 sessions::StatusController status; | |
| 809 ApplyPasswordUpdates(&status); | |
| 810 | |
| 811 EXPECT_EQ(1, status.num_encryption_conflicts()) | |
| 812 << "The updates that can't be decrypted should be in encryption " | |
| 813 << "conflict"; | |
| 814 EXPECT_EQ(1, status.num_updates_applied()) | |
| 815 << "The undecryptable password update shouldn't be applied"; | |
| 816 | |
| 817 { | |
| 818 syncable::ReadTransaction trans(FROM_HERE, directory()); | |
| 819 syncable::Entry e1(&trans, syncable::GET_BY_HANDLE, decryptable_handle); | |
| 820 syncable::Entry e2(&trans, syncable::GET_BY_HANDLE, undecryptable_handle); | |
| 821 ASSERT_TRUE(e1.good()); | |
| 822 ASSERT_TRUE(e2.good()); | |
| 823 EXPECT_FALSE(e1.GetIsUnappliedUpdate()); | |
| 824 EXPECT_TRUE(e2.GetIsUnappliedUpdate()); | |
| 825 } | |
| 826 } | |
| 827 | |
| 828 } // namespace syncer | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 161253002:
sync: Add interfaces for per-type sync (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src