Method to call a method with an entry based on its url

ios/chrome/browser/reading_list/reading_list_model_unittest.cc

 // Copyright 2016 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 "base/bind.h"
 #include "ios/chrome/browser/reading_list/reading_list_model_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
+const GURL callback_url("http://example.com");
+const std::string callback_title("test title");
+
 class ReadingListModelTest : public ReadingListModelObserver,
                              public testing::Test {
  public:
-  ReadingListModelTest() : model_(new ReadingListModelImpl()) {
+  ReadingListModelTest()
+      : callback_called_(false), model_(new ReadingListModelImpl()) {
     ClearCounts();
     model_->AddObserver(this);
   }
   ~ReadingListModelTest() override {}
 
   void ClearCounts() {
     observer_loaded_ = observer_started_batch_update_ =
         observer_completed_batch_update_ = observer_deleted_ =
             observer_remove_unread_ = observer_remove_read_ = observer_move_ =
                 observer_add_unread_ = observer_add_read_ =
@@ skipping 67 matching lines @@
                                         size_t index) override {
     observer_update_unread_ += 1;
   }
   void ReadingListWillUpdateReadEntry(const ReadingListModel* model,
                                       size_t index) override {
     observer_update_read_ += 1;
   }
   void ReadingListDidApplyChanges(ReadingListModel* model) override {
     observer_did_apply_ += 1;
   }
+  void Callback(const ReadingListEntry& entry) {
+    EXPECT_EQ(callback_url, entry.URL());
+    EXPECT_EQ(callback_title, entry.Title());
+    callback_called_ = true;
+  }
+
+  bool CallbackCalled() { return callback_called_; }
 
  protected:
   int observer_loaded_;
   int observer_started_batch_update_;
   int observer_completed_batch_update_;
   int observer_deleted_;
   int observer_remove_unread_;
   int observer_remove_read_;
   int observer_move_;
   int observer_add_unread_;
   int observer_add_read_;
   int observer_update_unread_;
   int observer_update_read_;
   int observer_did_apply_;
+  bool callback_called_;
 
   std::unique_ptr<ReadingListModelImpl> model_;
 };
 
 TEST_F(ReadingListModelTest, EmptyLoaded) {
   EXPECT_TRUE(model_->loaded());
   AssertObserverCount(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
   EXPECT_EQ(0ul, model_->unread_size());
   EXPECT_EQ(0ul, model_->read_size());
   model_->Shutdown();
@@ skipping 135 matching lines @@
   model_->MarkReadByURL(gurl);
   const ReadingListEntry& entry = model_->GetReadEntryAtIndex(0);
   ClearCounts();
 
   model_->SetEntryDistilledURL(gurl, gurl);
   AssertObserverCount(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1);
   EXPECT_EQ(ReadingListEntry::PROCESSED, entry.DistilledState());
   EXPECT_EQ(gurl, entry.DistilledURL());
 }
 
+// Tests that the callback is called when the entry is unread.
+TEST_F(ReadingListModelTest, CallbackEntryURLUnread) {
+  // Setup.
+  model_->AddEntry(callback_url, callback_title);
+
+  ASSERT_EQ(0UL, model_->read_size());
+  ASSERT_EQ(1UL, model_->unread_size());
+
+  // Action.
+  bool result = model_->CallbackEntryURL(
+      callback_url,
+      base::Bind(&ReadingListModelTest::Callback, base::Unretained(this)));
+
+  // Test.
+  EXPECT_TRUE(result);
+  EXPECT_TRUE(CallbackCalled());
+}
+
+// Tests that the callback is called when the entry is read.
+TEST_F(ReadingListModelTest, CallbackEntryURLRead) {
+  // Setup.
+  model_->AddEntry(callback_url, callback_title);
+  model_->MarkReadByURL(callback_url);
+
+  ASSERT_EQ(1UL, model_->read_size());
+  ASSERT_EQ(0UL, model_->unread_size());
+
+  // Action.
+  bool result = model_->CallbackEntryURL(
+      callback_url,
+      base::Bind(&ReadingListModelTest::Callback, base::Unretained(this)));
+
+  // Test.
+  EXPECT_TRUE(result);
+  EXPECT_TRUE(CallbackCalled());
+}
+
+// Tests that the callback is not called when the entry is not present.
+TEST_F(ReadingListModelTest, CallbackEntryURLNotPresent) {
+  // Setup.
+  const GURL gurl("http://foo.bar");
+  ASSERT_NE(gurl, callback_url);
+  model_->AddEntry(gurl, callback_title);
+
+  // Action.
+  bool result = model_->CallbackEntryURL(
+      callback_url,
+      base::Bind(&ReadingListModelTest::Callback, base::Unretained(this)));
+
+  // Test.
+  EXPECT_FALSE(result);
+  EXPECT_FALSE(CallbackCalled());
+}
+
 }  // namespace