Extract protobuf database into a new 'leveldb_proto' component

components/dom_distiller/core/dom_distiller_service_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/dom_distiller/core/dom_distiller_service.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/dom_distiller/core/article_entry.h"
 #include "components/dom_distiller/core/dom_distiller_model.h"
 #include "components/dom_distiller/core/dom_distiller_store.h"
 #include "components/dom_distiller/core/dom_distiller_test_util.h"
-#include "components/dom_distiller/core/fake_db.h"
 #include "components/dom_distiller/core/fake_distiller.h"
 #include "components/dom_distiller/core/fake_distiller_page.h"
 #include "components/dom_distiller/core/task_tracker.h"
+#include "components/leveldb_proto/testing/fake_db.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using leveldb_proto::test::FakeDB;
 using testing::Invoke;
 using testing::Return;
 using testing::_;
 
 namespace dom_distiller {
 namespace test {
 
 namespace {
 
 class FakeViewRequestDelegate : public ViewRequestDelegate {
@@ skipping 38 matching lines @@
   return CreateArticleWithURL("http://www.example.com/default_article_page1")
       .Pass();
 }
 
 }  // namespace
 
 class DomDistillerServiceTest : public testing::Test {
  public:
   virtual void SetUp() {
     main_loop_.reset(new base::MessageLoop());
-    FakeDB* fake_db = new FakeDB(&db_model_);
-    FakeDB::EntryMap store_model;
-    store_ = test::util::CreateStoreWithFakeDB(fake_db, store_model);
+    FakeDB<ArticleEntry>* fake_db = new FakeDB<ArticleEntry>(&db_model_);
+    FakeDB<ArticleEntry>::EntryMap store_model;
+    store_ =
+        test::util::CreateStoreWithFakeDB(fake_db, store_model);
     distiller_factory_ = new MockDistillerFactory();
     distiller_page_factory_ = new MockDistillerPageFactory();
     service_.reset(new DomDistillerService(
         scoped_ptr<DomDistillerStoreInterface>(store_),
         scoped_ptr<DistillerFactory>(distiller_factory_),
         scoped_ptr<DistillerPageFactory>(distiller_page_factory_)));
     fake_db->InitCallback(true);
     fake_db->LoadCallback(true);
   }
 
   virtual void TearDown() {
     base::RunLoop().RunUntilIdle();
     store_ = NULL;
     distiller_factory_ = NULL;
     service_.reset();
   }
 
  protected:
   // store is owned by service_.
   DomDistillerStoreInterface* store_;
   MockDistillerFactory* distiller_factory_;
   MockDistillerPageFactory* distiller_page_factory_;
   scoped_ptr<DomDistillerService> service_;
   scoped_ptr<base::MessageLoop> main_loop_;
-  FakeDB::EntryMap db_model_;
+  FakeDB<ArticleEntry>::EntryMap db_model_;
 };
 
 TEST_F(DomDistillerServiceTest, TestViewEntry) {
   FakeDistiller* distiller = new FakeDistiller(false);
   EXPECT_CALL(*distiller_factory_, CreateDistillerImpl())
       .WillOnce(Return(distiller));
 
   GURL url("http://www.example.com/p1");
   std::string entry_id("id0");
   ArticleEntry entry;
@@ skipping 117 matching lines @@
   FakeDistiller* distiller = new FakeDistiller(false);
   EXPECT_CALL(*distiller_factory_, CreateDistillerImpl())
       .WillOnce(Return(distiller));
 
   GURL url("http://www.example.com/p1");
 
   MockArticleAvailableCallback article_cb;
   EXPECT_CALL(article_cb, DistillationCompleted(true));
 
   std::string entry_id =
-      service_->AddToList(url,
-                          service_->CreateDefaultDistillerPage().Pass(),
+      service_->AddToList(url, service_->CreateDefaultDistillerPage().Pass(),
                           ArticleCallback(&article_cb));
 
   ASSERT_FALSE(distiller->GetArticleCallback().is_null());
   EXPECT_EQ(url, distiller->GetUrl());
 
   scoped_ptr<DistilledArticleProto> proto = CreateArticleWithURL(url.spec());
   RunDistillerCallback(distiller, proto.Pass());
 
   ArticleEntry entry;
   EXPECT_TRUE(store_->GetEntryByUrl(url, &entry));
@@ skipping 10 matching lines @@
   service_->AddObserver(&observer);
 
   EXPECT_CALL(*distiller_factory_, CreateDistillerImpl())
       .WillOnce(Return(distiller));
 
   MockArticleAvailableCallback article_cb;
   EXPECT_CALL(article_cb, DistillationCompleted(false));
 
   GURL url("http://www.example.com/p1");
   std::string entry_id =
-      service_->AddToList(url,
-                          service_->CreateDefaultDistillerPage().Pass(),
+      service_->AddToList(url, service_->CreateDefaultDistillerPage().Pass(),
                           ArticleCallback(&article_cb));
 
   // Remove entry will cause the |article_cb| to be called with false value.
   service_->RemoveEntry(entry_id);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(DomDistillerServiceTest, TestMultipleObservers) {
   FakeDistiller* distiller = new FakeDistiller(false);
   EXPECT_CALL(*distiller_factory_, CreateDistillerImpl())
@@ skipping 11 matching lines @@
       url, service_->CreateDefaultDistillerPage().Pass(), article_cb);
 
   // Distillation should notify all observers that article is added.
   std::vector<DomDistillerObserver::ArticleUpdate> expected_updates;
   DomDistillerObserver::ArticleUpdate update;
   update.entry_id = entry_id;
   update.update_type = DomDistillerObserver::ArticleUpdate::ADD;
   expected_updates.push_back(update);
 
   for (int i = 0; i < kObserverCount; ++i) {
-    EXPECT_CALL(
-        observers[i],
-        ArticleEntriesUpdated(util::HasExpectedUpdates(expected_updates)));
+    EXPECT_CALL(observers[i], ArticleEntriesUpdated(
+                                  util::HasExpectedUpdates(expected_updates)));
   }
 
   scoped_ptr<DistilledArticleProto> proto = CreateDefaultArticle();
   RunDistillerCallback(distiller, proto.Pass());
 
   // Remove should notify all observers that article is removed.
   update.update_type = DomDistillerObserver::ArticleUpdate::REMOVE;
   expected_updates.clear();
   expected_updates.push_back(update);
   for (int i = 0; i < kObserverCount; ++i) {
-    EXPECT_CALL(
-        observers[i],
-        ArticleEntriesUpdated(util::HasExpectedUpdates(expected_updates)));
+    EXPECT_CALL(observers[i], ArticleEntriesUpdated(
+                                  util::HasExpectedUpdates(expected_updates)));
   }
 
   service_->RemoveEntry(entry_id);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(DomDistillerServiceTest, TestMultipleCallbacks) {
   FakeDistiller* distiller = new FakeDistiller(false);
   EXPECT_CALL(*distiller_factory_, CreateDistillerImpl())
       .WillOnce(Return(distiller));
 
   const int kClientsCount = 5;
   MockArticleAvailableCallback article_cb[kClientsCount];
   // Adding a URL and then distilling calls all clients.
   GURL url("http://www.example.com/p1");
   const std::string entry_id =
-      service_->AddToList(url,
-                          service_->CreateDefaultDistillerPage().Pass(),
+      service_->AddToList(url, service_->CreateDefaultDistillerPage().Pass(),
                           ArticleCallback(&article_cb[0]));
   EXPECT_CALL(article_cb[0], DistillationCompleted(true));
 
   for (int i = 1; i < kClientsCount; ++i) {
-    EXPECT_EQ(entry_id,
-              service_->AddToList(url,
-                                  service_->CreateDefaultDistillerPage().Pass(),
-                                  ArticleCallback(&article_cb[i])));
+    EXPECT_EQ(entry_id, service_->AddToList(
+                            url, service_->CreateDefaultDistillerPage().Pass(),
+                            ArticleCallback(&article_cb[i])));
     EXPECT_CALL(article_cb[i], DistillationCompleted(true));
   }
 
   scoped_ptr<DistilledArticleProto> proto = CreateArticleWithURL(url.spec());
   RunDistillerCallback(distiller, proto.Pass());
 
   // Add the same url again, all callbacks should be called with true.
   for (int i = 0; i < kClientsCount; ++i) {
     EXPECT_CALL(article_cb[i], DistillationCompleted(true));
-    EXPECT_EQ(entry_id,
-              service_->AddToList(url,
-                                  service_->CreateDefaultDistillerPage().Pass(),
-                                  ArticleCallback(&article_cb[i])));
+    EXPECT_EQ(entry_id, service_->AddToList(
+                            url, service_->CreateDefaultDistillerPage().Pass(),
+                            ArticleCallback(&article_cb[i])));
   }
 
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(DomDistillerServiceTest, TestMultipleCallbacksOnRemove) {
   FakeDistiller* distiller = new FakeDistiller(false);
   EXPECT_CALL(*distiller_factory_, CreateDistillerImpl())
       .WillOnce(Return(distiller));
 
   const int kClientsCount = 5;
   MockArticleAvailableCallback article_cb[kClientsCount];
   // Adding a URL and remove the entry before distillation. Callback should be
   // called with false.
   GURL url("http://www.example.com/p1");
   const std::string entry_id =
-      service_->AddToList(url,
-                          service_->CreateDefaultDistillerPage().Pass(),
+      service_->AddToList(url, service_->CreateDefaultDistillerPage().Pass(),
                           ArticleCallback(&article_cb[0]));
 
   EXPECT_CALL(article_cb[0], DistillationCompleted(false));
   for (int i = 1; i < kClientsCount; ++i) {
-    EXPECT_EQ(entry_id,
-              service_->AddToList(url,
-                                  service_->CreateDefaultDistillerPage().Pass(),
-                                  ArticleCallback(&article_cb[i])));
+    EXPECT_EQ(entry_id, service_->AddToList(
+                            url, service_->CreateDefaultDistillerPage().Pass(),
+                            ArticleCallback(&article_cb[i])));
     EXPECT_CALL(article_cb[i], DistillationCompleted(false));
   }
 
   service_->RemoveEntry(entry_id);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(DomDistillerServiceTest, TestMultiplePageArticle) {
   FakeDistiller* distiller = new FakeDistiller(false);
   EXPECT_CALL(*distiller_factory_, CreateDistillerImpl())
       .WillOnce(Return(distiller));
 
   const int kPageCount = 8;
 
   std::string base_url("http://www.example.com/p");
   GURL pages_url[kPageCount];
   for (int page_num = 0; page_num < kPageCount; ++page_num) {
     pages_url[page_num] = GURL(base_url + base::IntToString(page_num));
   }
 
   MockArticleAvailableCallback article_cb;
   EXPECT_CALL(article_cb, DistillationCompleted(true));
 
-  std::string entry_id =
-      service_->AddToList(pages_url[0],
-                          service_->CreateDefaultDistillerPage().Pass(),
-                          ArticleCallback(&article_cb));
+  std::string entry_id = service_->AddToList(
+      pages_url[0], service_->CreateDefaultDistillerPage().Pass(),
+      ArticleCallback(&article_cb));
 
   ArticleEntry entry;
   ASSERT_FALSE(distiller->GetArticleCallback().is_null());
   EXPECT_EQ(pages_url[0], distiller->GetUrl());
 
   // Create the article with pages to pass to the distiller.
   scoped_ptr<DistilledArticleProto> proto =
       CreateArticleWithURL(pages_url[0].spec());
   for (int page_num = 1; page_num < kPageCount; ++page_num) {
     DistilledPageProto* distilled_page = proto->add_pages();
@@ skipping 17 matching lines @@
     EXPECT_TRUE(store_->GetEntryByUrl(pages_url[page_num], &entry));
   }
 
   service_->RemoveEntry(entry_id);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0u, store_->GetEntries().size());
 }
 
 }  // namespace test
 }  // namespace dom_distiller