[Offline] Creates metadata store interface for offline pages

components/offline_pages/offline_page_metadata_store_impl_unittest.cc

+// Copyright 2015 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/offline_pages/offline_page_metadata_store_impl.h"
+
+#include "base/bind.h"
+#include "base/files/file_path.h"
+#include "base/files/scoped_temp_dir.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "components/offline_pages/offline_page_item.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace offline_pages {
+
+namespace {
+
+const char kURL1[] = "https://example.com";
+const char kTitle1[] = "Exmample site title";
+const char kFilePath1[] = "/offline_pages/exmaple_com.mhtml";
+int64 kFileSize1 = 234567;
+
+class OfflinePageMetadataStoreImplTest : public testing::Test {
+ public:
+  enum CalledCallback { NONE, LOAD, ADD, REMOVE, DESTROY };
+
+  OfflinePageMetadataStoreImplTest();
+  ~OfflinePageMetadataStoreImplTest() override;
+
+  scoped_ptr<OfflinePageMetadataStoreImpl> BuildStore();
+  void PumpLoop();
+
+  void LoadCallback(OfflinePageMetadataStore::Status status,
+                    const std::vector<OfflinePageItem>& offline_pages);
+  void UpdateCallback(CalledCallback called_callback,
+                      OfflinePageMetadataStore::Status status);
+
+  void ClearResults();
+
+ protected:
+  CalledCallback last_called_callback_;
+  OfflinePageMetadataStore::Status last_status_;
+  std::vector<OfflinePageItem> offline_pages_;
+
+  base::ScopedTempDir temp_directory_;
+  base::MessageLoop message_loop_;
+  scoped_ptr<base::RunLoop> run_loop_;
+};
+
+OfflinePageMetadataStoreImplTest::OfflinePageMetadataStoreImplTest()
+    : last_called_callback_(NONE),
+      last_status_(OfflinePageMetadataStore::STATUS_COUNT) {
+  EXPECT_TRUE(temp_directory_.CreateUniqueTempDir());
+  run_loop_.reset(new base::RunLoop());
+}
+
+OfflinePageMetadataStoreImplTest::~OfflinePageMetadataStoreImplTest() {
+}
+
+void OfflinePageMetadataStoreImplTest::PumpLoop() {
+  message_loop_.RunUntilIdle();
+}
+
+scoped_ptr<OfflinePageMetadataStoreImpl>
+OfflinePageMetadataStoreImplTest::BuildStore() {
+  return scoped_ptr<OfflinePageMetadataStoreImpl>(
+      new OfflinePageMetadataStoreImpl(temp_directory_.path(),
+                                       message_loop_.message_loop_proxy()));
+}
+
+void OfflinePageMetadataStoreImplTest::LoadCallback(
+    OfflinePageMetadataStore::Status status,
+    const std::vector<OfflinePageItem>& offline_pages) {
+  last_called_callback_ = LOAD;
+  last_status_ = status;
+  offline_pages_.swap(const_cast<std::vector<OfflinePageItem>&>(offline_pages));
+  run_loop_->Quit();
+  run_loop_.reset(new base::RunLoop());
+}
+
+void OfflinePageMetadataStoreImplTest::UpdateCallback(
+    CalledCallback called_callback,
+    OfflinePageMetadataStore::Status status) {
+  last_called_callback_ = called_callback;
+  last_status_ = status;
+  run_loop_->Quit();
+  run_loop_.reset(new base::RunLoop());
+}
+
+void OfflinePageMetadataStoreImplTest::ClearResults() {
+  last_called_callback_ = NONE;
+  last_status_ = OfflinePageMetadataStore::STATUS_COUNT;
+  offline_pages_.clear();
+}
+
+// Loads empty store and makes sure that there are no offline pages stored in
+// it.
+TEST_F(OfflinePageMetadataStoreImplTest, LoadEmptyStore) {
+  scoped_ptr<OfflinePageMetadataStoreImpl> store(BuildStore());
+  store->Load(base::Bind(&OfflinePageMetadataStoreImplTest::LoadCallback,
+                         base::Unretained(this)));
+  PumpLoop();
+
+  EXPECT_EQ(LOAD, last_called_callback_);
+  EXPECT_EQ(OfflinePageMetadataStore::SUCCESS, last_status_);
+  EXPECT_EQ(0U, offline_pages_.size());
+}
+
+// Adds metadata of an offline page into a store and then loads from the
+// store to make sure the metadata is preserved.
+TEST_F(OfflinePageMetadataStoreImplTest, AddOfflinePageThenLoad) {
+  scoped_ptr<OfflinePageMetadataStoreImpl> store(BuildStore());
+
+  OfflinePageItem offline_page(GURL(kURL1), kTitle1, base::FilePath(kFilePath1),
+                               kFileSize1);
+  store->AddOfflinePage(
+      offline_page,
+      base::Bind(&OfflinePageMetadataStoreImplTest::UpdateCallback,
+                 base::Unretained(this), ADD));
+  PumpLoop();
+  EXPECT_EQ(ADD, last_called_callback_);
+  EXPECT_EQ(OfflinePageMetadataStore::SUCCESS, last_status_);
+
+  ClearResults();
+  store->Load(base::Bind(&OfflinePageMetadataStoreImplTest::LoadCallback,
+                         base::Unretained(this)));
+  PumpLoop();
+
+  EXPECT_EQ(LOAD, last_called_callback_);
+  EXPECT_EQ(OfflinePageMetadataStore::SUCCESS, last_status_);
+  EXPECT_EQ(1U, offline_pages_.size());
+  EXPECT_EQ(offline_page.url, offline_pages_[0].url);
+  EXPECT_EQ(offline_page.title, offline_pages_[0].title);
+  EXPECT_EQ(offline_page.version, offline_pages_[0].version);
+  EXPECT_EQ(offline_page.file_path, offline_pages_[0].file_path);
+  EXPECT_EQ(offline_page.file_size, offline_pages_[0].file_size);
+  EXPECT_EQ(offline_page.creation_time, offline_pages_[0].creation_time);
+  EXPECT_EQ(offline_page.last_access_time, offline_pages_[0].last_access_time);
+}
+
+// Adds metadata of an offline page into a store and then opens the store
+// again to make sure that stored metadata survives store restarts.
+TEST_F(OfflinePageMetadataStoreImplTest, AddOfflinePageRestartLoad) {
+  scoped_ptr<OfflinePageMetadataStoreImpl> store(BuildStore());
+
+  OfflinePageItem offline_page(GURL(kURL1), kTitle1, base::FilePath(kFilePath1),
+                               kFileSize1);
+  store->AddOfflinePage(
+      offline_page,
+      base::Bind(&OfflinePageMetadataStoreImplTest::UpdateCallback,
+                 base::Unretained(this), ADD));
+  PumpLoop();
+  EXPECT_EQ(ADD, last_called_callback_);
+  EXPECT_EQ(OfflinePageMetadataStore::SUCCESS, last_status_);
+
+  // Restart the store.
+  ClearResults();
+  store = BuildStore().Pass();
+  store->Load(base::Bind(&OfflinePageMetadataStoreImplTest::LoadCallback,
+                         base::Unretained(this)));
+  PumpLoop();
+
+  EXPECT_EQ(LOAD, last_called_callback_);
+  EXPECT_EQ(OfflinePageMetadataStore::SUCCESS, last_status_);
+  EXPECT_EQ(1U, offline_pages_.size());
+  EXPECT_EQ(offline_page.url, offline_pages_[0].url);
+  EXPECT_EQ(offline_page.title, offline_pages_[0].title);
+  EXPECT_EQ(offline_page.version, offline_pages_[0].version);
+  EXPECT_EQ(offline_page.file_path, offline_pages_[0].file_path);
+  EXPECT_EQ(offline_page.file_size, offline_pages_[0].file_size);
+  EXPECT_EQ(offline_page.creation_time, offline_pages_[0].creation_time);
+  EXPECT_EQ(offline_page.last_access_time, offline_pages_[0].last_access_time);
+}
+
+// Adds metadata of an offline page into a store and then opens the store
+// again to make sure that stored metadata survives store restarts.
+TEST_F(OfflinePageMetadataStoreImplTest, AddOfflinePageCloseLoad) {
+  scoped_ptr<OfflinePageMetadataStoreImpl> store(BuildStore());
+
+  OfflinePageItem offline_page(GURL(kURL1), kTitle1, base::FilePath(kFilePath1),
+                               kFileSize1);
+  store->AddOfflinePage(
+      offline_page,
+      base::Bind(&OfflinePageMetadataStoreImplTest::UpdateCallback,
+                 base::Unretained(this), ADD));
+  PumpLoop();
+  EXPECT_EQ(ADD, last_called_callback_);
+  EXPECT_EQ(OfflinePageMetadataStore::SUCCESS, last_status_);
+
+  ClearResults();
+  store->Close();
+  store->Load(base::Bind(&OfflinePageMetadataStoreImplTest::LoadCallback,
+                         base::Unretained(this)));
+  PumpLoop();
+
+  EXPECT_EQ(LOAD, last_called_callback_);
+  EXPECT_EQ(OfflinePageMetadataStore::SUCCESS, last_status_);
+  EXPECT_EQ(1U, offline_pages_.size());
+  EXPECT_EQ(offline_page.url, offline_pages_[0].url);
+  EXPECT_EQ(offline_page.title, offline_pages_[0].title);
+  EXPECT_EQ(offline_page.version, offline_pages_[0].version);
+  EXPECT_EQ(offline_page.file_path, offline_pages_[0].file_path);
+  EXPECT_EQ(offline_page.file_size, offline_pages_[0].file_size);
+  EXPECT_EQ(offline_page.creation_time, offline_pages_[0].creation_time);
+  EXPECT_EQ(offline_page.last_access_time, offline_pages_[0].last_access_time);
+}
+
+// Tests removing offline page metadata from the store, for which it first adds
+// metadata of an offline page.
+TEST_F(OfflinePageMetadataStoreImplTest, RemoveOfflinePage) {
+  scoped_ptr<OfflinePageMetadataStoreImpl> store(BuildStore());
+
+  OfflinePageItem offline_page(GURL(kURL1), kTitle1, base::FilePath(kFilePath1),
+                               kFileSize1);
+  store->AddOfflinePage(
+      offline_page,
+      base::Bind(&OfflinePageMetadataStoreImplTest::UpdateCallback,
+                 base::Unretained(this), ADD));
+  PumpLoop();
+  EXPECT_EQ(ADD, last_called_callback_);
+  EXPECT_EQ(OfflinePageMetadataStore::SUCCESS, last_status_);
+
+  ClearResults();
+  store->RemoveOfflinePage(
+      offline_page.url,
+      base::Bind(&OfflinePageMetadataStoreImplTest::UpdateCallback,
+                 base::Unretained(this), REMOVE));
+  PumpLoop();
+  EXPECT_EQ(REMOVE, last_called_callback_);
+  EXPECT_EQ(OfflinePageMetadataStore::SUCCESS, last_status_);
+
+  ClearResults();
+  store->Close();
+  store->Load(base::Bind(&OfflinePageMetadataStoreImplTest::LoadCallback,
+                         base::Unretained(this)));
+  PumpLoop();
+  EXPECT_EQ(LOAD, last_called_callback_);
+  EXPECT_EQ(OfflinePageMetadataStore::SUCCESS, last_status_);
+  EXPECT_EQ(0U, offline_pages_.size());
+}
+
+// Adds metadata of multiple offline pages into a store and removes some.
+TEST_F(OfflinePageMetadataStoreImplTest, AddRemoveMultipleOfflinePages) {
+  scoped_ptr<OfflinePageMetadataStoreImpl> store(BuildStore());
+
+  OfflinePageItem offline_page_1(GURL(kURL1), kTitle1,
+                                 base::FilePath(kFilePath1), kFileSize1);
+  OfflinePageItem offline_page_2(GURL("https://other.page.com"), "Other page",
+                                 base::FilePath("//other.page.com.mhtml"),
+                                 12345, base::Time::Now());
+  store->AddOfflinePage(
+      offline_page_1,
+      base::Bind(&OfflinePageMetadataStoreImplTest::UpdateCallback,
+                 base::Unretained(this), ADD));
+  PumpLoop();
+  EXPECT_EQ(ADD, last_called_callback_);
+  EXPECT_EQ(OfflinePageMetadataStore::SUCCESS, last_status_);
+
+  ClearResults();
+  store->AddOfflinePage(
+      offline_page_2,
+      base::Bind(&OfflinePageMetadataStoreImplTest::UpdateCallback,
+                 base::Unretained(this), ADD));
+  PumpLoop();
+  EXPECT_EQ(ADD, last_called_callback_);
+  EXPECT_EQ(OfflinePageMetadataStore::SUCCESS, last_status_);
+
+  ClearResults();
+  store->Load(base::Bind(&OfflinePageMetadataStoreImplTest::LoadCallback,
+                         base::Unretained(this)));
+  PumpLoop();
+
+  EXPECT_EQ(LOAD, last_called_callback_);
+  EXPECT_EQ(OfflinePageMetadataStore::SUCCESS, last_status_);
+  EXPECT_EQ(2U, offline_pages_.size());
+
+  store->RemoveOfflinePage(
+      offline_page_1.url,
+      base::Bind(&OfflinePageMetadataStoreImplTest::UpdateCallback,
+                 base::Unretained(this), REMOVE));
+  PumpLoop();
+  EXPECT_EQ(REMOVE, last_called_callback_);
+  EXPECT_EQ(OfflinePageMetadataStore::SUCCESS, last_status_);
+
+  ClearResults();
+  store->Close();
+  store->Load(base::Bind(&OfflinePageMetadataStoreImplTest::LoadCallback,
+                         base::Unretained(this)));
+  PumpLoop();
+
+  EXPECT_EQ(LOAD, last_called_callback_);
+  EXPECT_EQ(OfflinePageMetadataStore::SUCCESS, last_status_);
+  EXPECT_EQ(1U, offline_pages_.size());
+  EXPECT_EQ(offline_page_2.url, offline_pages_[0].url);
+  EXPECT_EQ(offline_page_2.title, offline_pages_[0].title);
+  EXPECT_EQ(offline_page_2.version, offline_pages_[0].version);
+  EXPECT_EQ(offline_page_2.file_path, offline_pages_[0].file_path);
+  EXPECT_EQ(offline_page_2.file_size, offline_pages_[0].file_size);
+  EXPECT_EQ(offline_page_2.creation_time, offline_pages_[0].creation_time);
+  EXPECT_EQ(offline_page_2.last_access_time,
+            offline_pages_[0].last_access_time);
+}
+
+// Adds metadata of multiple offline pages into a store and removes some.
+TEST_F(OfflinePageMetadataStoreImplTest, DestroyStore) {
+  scoped_ptr<OfflinePageMetadataStoreImpl> store(BuildStore());
+
+  OfflinePageItem offline_page_1(GURL(kURL1), kTitle1,
+                                 base::FilePath(kFilePath1), kFileSize1);
+  OfflinePageItem offline_page_2(GURL("https://other.page.com"), "Other page",
+                                 base::FilePath("//other.page.com.mhtml"),
+                                 12345, base::Time::Now());
+  store->AddOfflinePage(
+      offline_page_1,
+      base::Bind(&OfflinePageMetadataStoreImplTest::UpdateCallback,
+                 base::Unretained(this), ADD));
+  PumpLoop();
+  store->AddOfflinePage(
+      offline_page_2,
+      base::Bind(&OfflinePageMetadataStoreImplTest::UpdateCallback,
+                 base::Unretained(this), ADD));
+  PumpLoop();
+
+  ClearResults();
+  store->Destroy(base::Bind(&OfflinePageMetadataStoreImplTest::UpdateCallback,
+                            base::Unretained(this), DESTROY));
+  PumpLoop();
+  EXPECT_EQ(DESTROY, last_called_callback_);
+  EXPECT_EQ(OfflinePageMetadataStore::SUCCESS, last_status_);
+
+  ClearResults();
+  store->Load(base::Bind(&OfflinePageMetadataStoreImplTest::LoadCallback,
+                         base::Unretained(this)));
+  PumpLoop();
+
+  EXPECT_EQ(LOAD, last_called_callback_);
+  EXPECT_EQ(OfflinePageMetadataStore::SUCCESS, last_status_);
+  EXPECT_TRUE(offline_pages_.empty());
+}
+
+}  // namespace
+
+}  // namespace offline_pages