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 "components/dom_distiller/core/dom_distiller_store.h" 6 7 #include "base/bind.h" 8 #include "base/file_util.h" 9 #include "base/files/scoped_temp_dir.h" 10 #include "base/message_loop/message_loop.h" 11 #include "base/run_loop.h" 12 #include "base/time/time.h" 13 #include "components/dom_distiller/core/article_entry.h" 14 #include "components/dom_distiller/core/dom_distiller_test_util.h" 15 #include "components/leveldb_proto/testing/fake_db.h" 16 #include "sync/api/attachments/attachment_id.h" 17 #include "sync/api/attachments/attachment_service_proxy_for_test.h" 18 #include "sync/protocol/sync.pb.h" 19 #include "testing/gmock/include/gmock/gmock.h" 20 #include "testing/gtest/include/gtest/gtest.h" 21 22 using base::Time; 23 using leveldb_proto::test::FakeDB; 24 using sync_pb::EntitySpecifics; 25 using syncer::ModelType; 26 using syncer::SyncChange; 27 using syncer::SyncChangeList; 28 using syncer::SyncChangeProcessor; 29 using syncer::SyncData; 30 using syncer::SyncDataList; 31 using syncer::SyncError; 32 using syncer::SyncErrorFactory; 33 using testing::AssertionFailure; 34 using testing::AssertionResult; 35 using testing::AssertionSuccess; 36 37 namespace dom_distiller { 38 39 namespace { 40 41 const ModelType kDomDistillerModelType = syncer::ARTICLES; 42 43 typedef base::hash_map<std::string, ArticleEntry> EntryMap; 44 45 void AddEntry(const ArticleEntry& e, EntryMap* map) { 46 (*map)[e.entry_id()] = e; 47 } 48 49 class FakeSyncErrorFactory : public syncer::SyncErrorFactory { 50 public: 51 virtual syncer::SyncError CreateAndUploadError( 52 const tracked_objects::Location& location, 53 const std::string& message) OVERRIDE { 54 return syncer::SyncError(); 55 } 56 }; 57 58 class FakeSyncChangeProcessor : public syncer::SyncChangeProcessor { 59 public: 60 explicit FakeSyncChangeProcessor(EntryMap* model) : model_(model) {} 61 62 virtual syncer::SyncDataList GetAllSyncData( 63 syncer::ModelType type) const OVERRIDE { 64 ADD_FAILURE() << "FakeSyncChangeProcessor::GetAllSyncData not implemented."; 65 return syncer::SyncDataList(); 66 } 67 68 virtual SyncError ProcessSyncChanges( 69 const tracked_objects::Location&, 70 const syncer::SyncChangeList& changes) OVERRIDE { 71 for (SyncChangeList::const_iterator it = changes.begin(); 72 it != changes.end(); ++it) { 73 AddEntry(GetEntryFromChange(*it), model_); 74 } 75 return SyncError(); 76 } 77 78 private: 79 EntryMap* model_; 80 }; 81 82 ArticleEntry CreateEntry(std::string entry_id, std::string page_url1, 83 std::string page_url2, std::string page_url3) { 84 ArticleEntry entry; 85 entry.set_entry_id(entry_id); 86 if (!page_url1.empty()) { 87 ArticleEntryPage* page = entry.add_pages(); 88 page->set_url(page_url1); 89 } 90 if (!page_url2.empty()) { 91 ArticleEntryPage* page = entry.add_pages(); 92 page->set_url(page_url2); 93 } 94 if (!page_url3.empty()) { 95 ArticleEntryPage* page = entry.add_pages(); 96 page->set_url(page_url3); 97 } 98 return entry; 99 } 100 101 ArticleEntry GetSampleEntry(int id) { 102 static ArticleEntry entries[] = { 103 CreateEntry("entry0", "example.com/1", "example.com/2", "example.com/3"), 104 CreateEntry("entry1", "example.com/1", "", ""), 105 CreateEntry("entry2", "example.com/p1", "example.com/p2", ""), 106 CreateEntry("entry3", "example.com/something/all", "", ""), 107 CreateEntry("entry4", "example.com/somethingelse/1", "", ""), 108 CreateEntry("entry5", "rock.example.com/p1", "rock.example.com/p2", ""), 109 CreateEntry("entry7", "example.com/entry7/1", "example.com/entry7/2", ""), 110 CreateEntry("entry8", "example.com/entry8/1", "", ""), 111 CreateEntry("entry9", "example.com/entry9/all", "", ""), 112 }; 113 EXPECT_LT(id, 9); 114 return entries[id % 9]; 115 } 116 117 class MockDistillerObserver : public DomDistillerObserver { 118 public: 119 MOCK_METHOD1(ArticleEntriesUpdated, void(const std::vector<ArticleUpdate>&)); 120 virtual ~MockDistillerObserver() {} 121 }; 122 123 } // namespace 124 125 class DomDistillerStoreTest : public testing::Test { 126 public: 127 virtual void SetUp() { 128 db_model_.clear(); 129 sync_model_.clear(); 130 store_model_.clear(); 131 next_sync_id_ = 1; 132 } 133 134 virtual void TearDown() { 135 store_.reset(); 136 fake_db_ = NULL; 137 fake_sync_processor_ = NULL; 138 } 139 140 // Creates a simple DomDistillerStore initialized with |store_model_| and 141 // with a FakeDB backed by |db_model_|. 142 void CreateStore() { 143 fake_db_ = new FakeDB<ArticleEntry>(&db_model_); 144 store_.reset(test::util::CreateStoreWithFakeDB(fake_db_, store_model_)); 145 } 146 147 void StartSyncing() { 148 fake_sync_processor_ = new FakeSyncChangeProcessor(&sync_model_); 149 150 store_->MergeDataAndStartSyncing( 151 kDomDistillerModelType, SyncDataFromEntryMap(sync_model_), 152 make_scoped_ptr<SyncChangeProcessor>(fake_sync_processor_), 153 scoped_ptr<SyncErrorFactory>(new FakeSyncErrorFactory())); 154 } 155 156 protected: 157 SyncData CreateSyncData(const ArticleEntry& entry) { 158 EntitySpecifics specifics = SpecificsFromEntry(entry); 159 return SyncData::CreateRemoteData( 160 next_sync_id_++, specifics, Time::UnixEpoch(), 161 syncer::AttachmentIdList(), 162 syncer::AttachmentServiceProxyForTest::Create()); 163 } 164 165 SyncDataList SyncDataFromEntryMap(const EntryMap& model) { 166 SyncDataList data; 167 for (EntryMap::const_iterator it = model.begin(); it != model.end(); ++it) { 168 data.push_back(CreateSyncData(it->second)); 169 } 170 return data; 171 } 172 173 base::MessageLoop message_loop_; 174 175 EntryMap db_model_; 176 EntryMap sync_model_; 177 FakeDB<ArticleEntry>::EntryMap store_model_; 178 179 scoped_ptr<DomDistillerStore> store_; 180 181 // Both owned by |store_|. 182 FakeDB<ArticleEntry>* fake_db_; 183 FakeSyncChangeProcessor* fake_sync_processor_; 184 185 int64 next_sync_id_; 186 }; 187 188 AssertionResult AreEntriesEqual(const DomDistillerStore::EntryVector& entries, 189 EntryMap expected_entries) { 190 if (entries.size() != expected_entries.size()) 191 return AssertionFailure() << "Expected " << expected_entries.size() 192 << " entries but found " << entries.size(); 193 194 for (DomDistillerStore::EntryVector::const_iterator it = entries.begin(); 195 it != entries.end(); ++it) { 196 EntryMap::iterator expected_it = expected_entries.find(it->entry_id()); 197 if (expected_it == expected_entries.end()) { 198 return AssertionFailure() << "Found unexpected entry with id <" 199 << it->entry_id() << ">"; 200 } 201 if (!AreEntriesEqual(expected_it->second, *it)) { 202 return AssertionFailure() << "Mismatched entry with id <" 203 << it->entry_id() << ">"; 204 } 205 expected_entries.erase(expected_it); 206 } 207 return AssertionSuccess(); 208 } 209 210 AssertionResult AreEntryMapsEqual(const EntryMap& left, const EntryMap& right) { 211 DomDistillerStore::EntryVector entries; 212 for (EntryMap::const_iterator it = left.begin(); it != left.end(); ++it) { 213 entries.push_back(it->second); 214 } 215 return AreEntriesEqual(entries, right); 216 } 217 218 TEST_F(DomDistillerStoreTest, TestDatabaseLoad) { 219 AddEntry(GetSampleEntry(0), &db_model_); 220 AddEntry(GetSampleEntry(1), &db_model_); 221 AddEntry(GetSampleEntry(2), &db_model_); 222 223 CreateStore(); 224 225 fake_db_->InitCallback(true); 226 EXPECT_EQ(fake_db_->GetDirectory(), 227 FakeDB<ArticleEntry>::DirectoryForTestDB()); 228 229 fake_db_->LoadCallback(true); 230 EXPECT_TRUE(AreEntriesEqual(store_->GetEntries(), db_model_)); 231 } 232 233 TEST_F(DomDistillerStoreTest, TestDatabaseLoadMerge) { 234 AddEntry(GetSampleEntry(0), &db_model_); 235 AddEntry(GetSampleEntry(1), &db_model_); 236 AddEntry(GetSampleEntry(2), &db_model_); 237 238 AddEntry(GetSampleEntry(2), &store_model_); 239 AddEntry(GetSampleEntry(3), &store_model_); 240 AddEntry(GetSampleEntry(4), &store_model_); 241 242 EntryMap expected_model(db_model_); 243 AddEntry(GetSampleEntry(3), &expected_model); 244 AddEntry(GetSampleEntry(4), &expected_model); 245 246 CreateStore(); 247 fake_db_->InitCallback(true); 248 fake_db_->LoadCallback(true); 249 250 EXPECT_TRUE(AreEntriesEqual(store_->GetEntries(), expected_model)); 251 EXPECT_TRUE(AreEntryMapsEqual(db_model_, expected_model)); 252 } 253 254 TEST_F(DomDistillerStoreTest, TestAddAndRemoveEntry) { 255 CreateStore(); 256 fake_db_->InitCallback(true); 257 fake_db_->LoadCallback(true); 258 259 EXPECT_TRUE(store_->GetEntries().empty()); 260 EXPECT_TRUE(db_model_.empty()); 261 262 store_->AddEntry(GetSampleEntry(0)); 263 264 EntryMap expected_model; 265 AddEntry(GetSampleEntry(0), &expected_model); 266 267 EXPECT_TRUE(AreEntriesEqual(store_->GetEntries(), expected_model)); 268 EXPECT_TRUE(AreEntryMapsEqual(db_model_, expected_model)); 269 270 store_->RemoveEntry(GetSampleEntry(0)); 271 expected_model.clear(); 272 273 EXPECT_TRUE(AreEntriesEqual(store_->GetEntries(), expected_model)); 274 EXPECT_TRUE(AreEntryMapsEqual(db_model_, expected_model)); 275 } 276 277 TEST_F(DomDistillerStoreTest, TestAddAndUpdateEntry) { 278 CreateStore(); 279 fake_db_->InitCallback(true); 280 fake_db_->LoadCallback(true); 281 282 EXPECT_TRUE(store_->GetEntries().empty()); 283 EXPECT_TRUE(db_model_.empty()); 284 285 store_->AddEntry(GetSampleEntry(0)); 286 287 EntryMap expected_model; 288 AddEntry(GetSampleEntry(0), &expected_model); 289 290 EXPECT_TRUE(AreEntriesEqual(store_->GetEntries(), expected_model)); 291 EXPECT_TRUE(AreEntryMapsEqual(db_model_, expected_model)); 292 293 EXPECT_FALSE(store_->UpdateEntry(GetSampleEntry(0))); 294 295 ArticleEntry updated_entry(GetSampleEntry(0)); 296 updated_entry.set_title("updated title."); 297 EXPECT_TRUE(store_->UpdateEntry(updated_entry)); 298 expected_model.clear(); 299 AddEntry(updated_entry, &expected_model); 300 301 EXPECT_TRUE(AreEntriesEqual(store_->GetEntries(), expected_model)); 302 EXPECT_TRUE(AreEntryMapsEqual(db_model_, expected_model)); 303 304 store_->RemoveEntry(updated_entry); 305 EXPECT_FALSE(store_->UpdateEntry(updated_entry)); 306 EXPECT_FALSE(store_->UpdateEntry(GetSampleEntry(0))); 307 } 308 309 TEST_F(DomDistillerStoreTest, TestSyncMergeWithEmptyDatabase) { 310 AddEntry(GetSampleEntry(0), &sync_model_); 311 AddEntry(GetSampleEntry(1), &sync_model_); 312 AddEntry(GetSampleEntry(2), &sync_model_); 313 314 CreateStore(); 315 fake_db_->InitCallback(true); 316 fake_db_->LoadCallback(true); 317 318 StartSyncing(); 319 320 EXPECT_TRUE(AreEntriesEqual(store_->GetEntries(), sync_model_)); 321 EXPECT_TRUE(AreEntryMapsEqual(db_model_, sync_model_)); 322 } 323 324 TEST_F(DomDistillerStoreTest, TestSyncMergeAfterDatabaseLoad) { 325 AddEntry(GetSampleEntry(0), &db_model_); 326 AddEntry(GetSampleEntry(1), &db_model_); 327 AddEntry(GetSampleEntry(2), &db_model_); 328 329 AddEntry(GetSampleEntry(2), &sync_model_); 330 AddEntry(GetSampleEntry(3), &sync_model_); 331 AddEntry(GetSampleEntry(4), &sync_model_); 332 333 EntryMap expected_model(db_model_); 334 AddEntry(GetSampleEntry(3), &expected_model); 335 AddEntry(GetSampleEntry(4), &expected_model); 336 337 CreateStore(); 338 fake_db_->InitCallback(true); 339 fake_db_->LoadCallback(true); 340 341 EXPECT_TRUE(AreEntriesEqual(store_->GetEntries(), db_model_)); 342 343 StartSyncing(); 344 345 EXPECT_TRUE(AreEntriesEqual(store_->GetEntries(), expected_model)); 346 EXPECT_TRUE(AreEntryMapsEqual(db_model_, expected_model)); 347 EXPECT_TRUE(AreEntryMapsEqual(sync_model_, expected_model)); 348 } 349 350 TEST_F(DomDistillerStoreTest, TestGetAllSyncData) { 351 AddEntry(GetSampleEntry(0), &db_model_); 352 AddEntry(GetSampleEntry(1), &db_model_); 353 AddEntry(GetSampleEntry(2), &db_model_); 354 355 AddEntry(GetSampleEntry(2), &sync_model_); 356 AddEntry(GetSampleEntry(3), &sync_model_); 357 AddEntry(GetSampleEntry(4), &sync_model_); 358 359 EntryMap expected_model(db_model_); 360 AddEntry(GetSampleEntry(3), &expected_model); 361 AddEntry(GetSampleEntry(4), &expected_model); 362 363 CreateStore(); 364 365 fake_db_->InitCallback(true); 366 fake_db_->LoadCallback(true); 367 368 StartSyncing(); 369 370 SyncDataList data = store_->GetAllSyncData(kDomDistillerModelType); 371 DomDistillerStore::EntryVector entries; 372 for (SyncDataList::iterator it = data.begin(); it != data.end(); ++it) { 373 entries.push_back(EntryFromSpecifics(it->GetSpecifics())); 374 } 375 EXPECT_TRUE(AreEntriesEqual(entries, expected_model)); 376 } 377 378 TEST_F(DomDistillerStoreTest, TestProcessSyncChanges) { 379 AddEntry(GetSampleEntry(0), &db_model_); 380 AddEntry(GetSampleEntry(1), &db_model_); 381 sync_model_ = db_model_; 382 383 EntryMap expected_model(db_model_); 384 AddEntry(GetSampleEntry(2), &expected_model); 385 AddEntry(GetSampleEntry(3), &expected_model); 386 387 CreateStore(); 388 389 fake_db_->InitCallback(true); 390 fake_db_->LoadCallback(true); 391 392 StartSyncing(); 393 394 SyncChangeList changes; 395 changes.push_back(SyncChange(FROM_HERE, SyncChange::ACTION_ADD, 396 CreateSyncData(GetSampleEntry(2)))); 397 changes.push_back(SyncChange(FROM_HERE, SyncChange::ACTION_ADD, 398 CreateSyncData(GetSampleEntry(3)))); 399 400 store_->ProcessSyncChanges(FROM_HERE, changes); 401 402 EXPECT_TRUE(AreEntriesEqual(store_->GetEntries(), expected_model)); 403 EXPECT_TRUE(AreEntryMapsEqual(db_model_, expected_model)); 404 } 405 406 TEST_F(DomDistillerStoreTest, TestSyncMergeWithSecondDomDistillerStore) { 407 AddEntry(GetSampleEntry(0), &db_model_); 408 AddEntry(GetSampleEntry(1), &db_model_); 409 AddEntry(GetSampleEntry(2), &db_model_); 410 411 EntryMap other_db_model; 412 AddEntry(GetSampleEntry(2), &other_db_model); 413 AddEntry(GetSampleEntry(3), &other_db_model); 414 AddEntry(GetSampleEntry(4), &other_db_model); 415 416 EntryMap expected_model(db_model_); 417 AddEntry(GetSampleEntry(3), &expected_model); 418 AddEntry(GetSampleEntry(4), &expected_model); 419 420 CreateStore(); 421 422 fake_db_->InitCallback(true); 423 fake_db_->LoadCallback(true); 424 425 FakeDB<ArticleEntry>* other_fake_db = 426 new FakeDB<ArticleEntry>(&other_db_model); 427 scoped_ptr<DomDistillerStore> owned_other_store(new DomDistillerStore( 428 scoped_ptr<leveldb_proto::ProtoDatabase<ArticleEntry> >(other_fake_db), 429 std::vector<ArticleEntry>(), 430 base::FilePath(FILE_PATH_LITERAL("/fake/other/path")))); 431 DomDistillerStore* other_store = owned_other_store.get(); 432 other_fake_db->InitCallback(true); 433 other_fake_db->LoadCallback(true); 434 435 EXPECT_FALSE(AreEntriesEqual(store_->GetEntries(), expected_model)); 436 EXPECT_FALSE(AreEntriesEqual(other_store->GetEntries(), expected_model)); 437 ASSERT_TRUE(AreEntriesEqual(other_store->GetEntries(), other_db_model)); 438 439 FakeSyncErrorFactory* other_error_factory = new FakeSyncErrorFactory(); 440 store_->MergeDataAndStartSyncing( 441 kDomDistillerModelType, SyncDataFromEntryMap(other_db_model), 442 owned_other_store.PassAs<SyncChangeProcessor>(), 443 make_scoped_ptr<SyncErrorFactory>(other_error_factory)); 444 445 EXPECT_TRUE(AreEntriesEqual(store_->GetEntries(), expected_model)); 446 EXPECT_TRUE(AreEntriesEqual(other_store->GetEntries(), expected_model)); 447 } 448 449 TEST_F(DomDistillerStoreTest, TestObserver) { 450 CreateStore(); 451 MockDistillerObserver observer; 452 store_->AddObserver(&observer); 453 fake_db_->InitCallback(true); 454 fake_db_->LoadCallback(true); 455 std::vector<DomDistillerObserver::ArticleUpdate> expected_updates; 456 DomDistillerObserver::ArticleUpdate update; 457 update.entry_id = GetSampleEntry(0).entry_id(); 458 update.update_type = DomDistillerObserver::ArticleUpdate::ADD; 459 expected_updates.push_back(update); 460 EXPECT_CALL(observer, ArticleEntriesUpdated( 461 test::util::HasExpectedUpdates(expected_updates))); 462 store_->AddEntry(GetSampleEntry(0)); 463 464 expected_updates.clear(); 465 update.entry_id = GetSampleEntry(1).entry_id(); 466 update.update_type = DomDistillerObserver::ArticleUpdate::ADD; 467 expected_updates.push_back(update); 468 EXPECT_CALL(observer, ArticleEntriesUpdated( 469 test::util::HasExpectedUpdates(expected_updates))); 470 store_->AddEntry(GetSampleEntry(1)); 471 472 expected_updates.clear(); 473 update.entry_id = GetSampleEntry(0).entry_id(); 474 update.update_type = DomDistillerObserver::ArticleUpdate::REMOVE; 475 expected_updates.clear(); 476 expected_updates.push_back(update); 477 EXPECT_CALL(observer, ArticleEntriesUpdated( 478 test::util::HasExpectedUpdates(expected_updates))); 479 store_->RemoveEntry(GetSampleEntry(0)); 480 481 // Add entry_id = 3 and update entry_id = 1. 482 expected_updates.clear(); 483 SyncDataList change_data; 484 change_data.push_back(CreateSyncData(GetSampleEntry(3))); 485 ArticleEntry updated_entry(GetSampleEntry(1)); 486 updated_entry.set_title("changed_title"); 487 change_data.push_back(CreateSyncData(updated_entry)); 488 update.entry_id = GetSampleEntry(3).entry_id(); 489 update.update_type = DomDistillerObserver::ArticleUpdate::ADD; 490 expected_updates.push_back(update); 491 update.entry_id = GetSampleEntry(1).entry_id(); 492 update.update_type = DomDistillerObserver::ArticleUpdate::UPDATE; 493 expected_updates.push_back(update); 494 EXPECT_CALL(observer, ArticleEntriesUpdated( 495 test::util::HasExpectedUpdates(expected_updates))); 496 497 FakeSyncErrorFactory* fake_error_factory = new FakeSyncErrorFactory(); 498 EntryMap fake_model; 499 FakeSyncChangeProcessor* fake_sync_change_processor = 500 new FakeSyncChangeProcessor(&fake_model); 501 store_->MergeDataAndStartSyncing( 502 kDomDistillerModelType, change_data, 503 make_scoped_ptr<SyncChangeProcessor>(fake_sync_change_processor), 504 make_scoped_ptr<SyncErrorFactory>(fake_error_factory)); 505 } 506 507 } // namespace dom_distiller 508
