[Offline pages] Updating the UpdateCallback in OPMStoreSQL

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.h"
 
 #include <stdint.h>
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/offline_pages/offline_page_item.h"
 #include "components/offline_pages/offline_page_metadata_store_sql.h"
 #include "components/offline_pages/offline_page_model.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace offline_pages {
 
 namespace {
 
+using ItemActionStatus = OfflinePageMetadataStore::ItemActionStatus;
+
 #define OFFLINE_PAGES_TABLE_V1 "offlinepages_v1"
 
 const char kTestClientNamespace[] = "CLIENT_NAMESPACE";
 const char kTestURL[] = "https://example.com";
 const ClientId kTestClientId1(kTestClientNamespace, "1234");
 const ClientId kTestClientId2(kTestClientNamespace, "5678");
 const base::FilePath::CharType kFilePath[] =
     FILE_PATH_LITERAL("/offline_pages/example_com.mhtml");
 int64_t kFileSize = 234567LL;
 int64_t kOfflineId = 12345LL;
@@ skipping 187 matching lines @@
   std::unique_ptr<OfflinePageMetadataStore> BuildStore();
   std::unique_ptr<OfflinePageMetadataStore> BuildStoreWithSchemaFromM52();
   std::unique_ptr<OfflinePageMetadataStore> BuildStoreWithSchemaFromM53();
   std::unique_ptr<OfflinePageMetadataStore> BuildStoreWithSchemaFromM54();
 
   void PumpLoop();
 
   void GetOfflinePagesCallback(
       OfflinePageMetadataStore::LoadStatus load_status,
       const std::vector<OfflinePageItem>& offline_pages);
-  void AddCallback(OfflinePageMetadataStore::ItemActionStatus status);
-  void UpdateCallback(CalledCallback called_callback, bool success);
+  void AddCallback(ItemActionStatus status);
+  void UpdateCallback(CalledCallback called_callback,
+                      const std::map<int64_t, ItemActionStatus>& failed_items,
+                      const std::vector<OfflinePageItem>& updated_items);
+  void ResetCallback(bool status);
 
   void ClearResults();
 
   OfflinePageItem CheckThatStoreHasOneItem();
   void CheckThatOfflinePageCanBeSaved(
       std::unique_ptr<OfflinePageMetadataStore> store);
 
  protected:
   CalledCallback last_called_callback_;
   Status last_status_;
@@ skipping 21 matching lines @@
 
 void OfflinePageMetadataStoreTest::GetOfflinePagesCallback(
     OfflinePageMetadataStore::LoadStatus load_status,
     const std::vector<OfflinePageItem>& offline_pages) {
   last_called_callback_ = LOAD;
   last_status_ = load_status == OfflinePageMetadataStore::LOAD_SUCCEEDED ?
       STATUS_TRUE : STATUS_FALSE;
   offline_pages_.swap(const_cast<std::vector<OfflinePageItem>&>(offline_pages));
 }
 
-void OfflinePageMetadataStoreTest::AddCallback(
-    OfflinePageMetadataStore::ItemActionStatus status) {
+void OfflinePageMetadataStoreTest::AddCallback(ItemActionStatus status) {
   last_called_callback_ = ADD;
   // TODO(fgorski): Add specific add status.
   // last_item_status_ = status;
   last_status_ =
       status == OfflinePageMetadataStore::SUCCESS ? STATUS_TRUE : STATUS_FALSE;
 }
 
 void OfflinePageMetadataStoreTest::UpdateCallback(
     CalledCallback called_callback,
-    bool status) {
+    const std::map<int64_t, ItemActionStatus>& failed_items,
+    const std::vector<OfflinePageItem>& updated_items) {
   last_called_callback_ = called_callback;
+  last_status_ = updated_items.size() > 0 ? STATUS_TRUE : STATUS_FALSE;

[Pete Williamson, 2016/09/15 18:05:43]

Should we save more information here?  This doesn't capture if any items failed
the update.  Maybe save a copy of failed_items, so we can see if the size is
non-zero in unit tests.

[fgorski, 2016/09/19 23:24:30]

Done. I actually take the ownership of the result. I am doing basic validation
in tests, but we can extend that further.

+}
+
+void OfflinePageMetadataStoreTest::ResetCallback(bool status) {
+  last_called_callback_ = RESET;
   last_status_ = status ? STATUS_TRUE : STATUS_FALSE;
 }
 
 void OfflinePageMetadataStoreTest::ClearResults() {
   last_called_callback_ = NONE;
   last_status_ = STATUS_NONE;
   offline_pages_.clear();
 }
 
 OfflinePageItem OfflinePageMetadataStoreTest::CheckThatStoreHasOneItem() {
@@ skipping 398 matching lines @@
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
 
   EXPECT_EQ(LOAD, last_called_callback_);
   EXPECT_EQ(STATUS_TRUE, last_status_);
   EXPECT_EQ(2U, offline_pages_.size());
 
   // Clear all records from the store.
-  store->Reset(base::Bind(&OfflinePageMetadataStoreTest::UpdateCallback,
-                          base::Unretained(this), RESET));
+  store->Reset(base::Bind(&OfflinePageMetadataStoreTest::ResetCallback,
+                          base::Unretained(this)));
   PumpLoop();
   EXPECT_EQ(RESET, last_called_callback_);
   EXPECT_EQ(STATUS_TRUE, last_status_);
 
   // Load the store.
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
 
   EXPECT_EQ(LOAD, last_called_callback_);
   EXPECT_EQ(STATUS_TRUE, last_status_);
   ASSERT_EQ(0U, offline_pages_.size());
 }
 
 }  // namespace
 }  // namespace offline_pages