FetchMore functionality backend

components/ntp_snippets/remote/ntp_snippets_service_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/ntp_snippets/remote/ntp_snippets_service.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 370 matching lines @@
  public:
   NTPSnippetsServiceTest()
       : params_manager_(ntp_snippets::kStudyName,
                         {{"content_suggestions_backend",
                           kTestContentSuggestionsServerEndpoint}}),
         fake_url_fetcher_factory_(
             /*default_factory=*/&failing_url_fetcher_factory_),
         test_url_(kTestContentSuggestionsServerWithAPIKey),
         user_classifier_(/*pref_service=*/nullptr),
         image_fetcher_(nullptr),
-        image_decoder_(nullptr) {
+        image_decoder_(nullptr),
+        caller_() {
     NTPSnippetsService::RegisterProfilePrefs(utils_.pref_service()->registry());
     RequestThrottler::RegisterProfilePrefs(utils_.pref_service()->registry());
 
     EXPECT_TRUE(database_dir_.CreateUniqueTempDir());
   }
 
   ~NTPSnippetsServiceTest() override {
     // We need to run the message loop after deleting the database, because
     // ProtoDatabaseImpl deletes the actual LevelDB asynchronously on the task
     // runner. Without this, we'd get reports of memory leaks.
@@ skipping 94 matching lines @@
                                               net::URLRequestStatus::SUCCESS);
   }
 
   void LoadFromJSONString(NTPSnippetsService* service,
                           const std::string& json) {
     SetUpFetchResponse(json);
     service->FetchSnippets(true);
     base::RunLoop().RunUntilIdle();
   }
 
+  void LoadMoreFromJSONString(NTPSnippetsService* service,
+                              const std::string& json,
+                              const std::set<std::string>& known_ids,
+                              NTPSnippetsService::FetchingCallback callback) {
+    SetUpFetchResponse(json);
+    service->Fetch(articles_category(), known_ids, callback);
+    base::RunLoop().RunUntilIdle();
+  }
+
  private:
+  class MockCaller {
+   public:
+    void EmptyCallback(std::vector<ContentSuggestion>) {}
+    void CheckCallback(std::vector<ContentSuggestion> v) { MustCallback(); }
+    MOCK_METHOD0(MustCallback, void());
+  };
+
   variations::testing::VariationParamsManager params_manager_;
   test::NTPSnippetsTestUtils utils_;
   base::MessageLoop message_loop_;
   FailingFakeURLFetcherFactory failing_url_fetcher_factory_;
   // Instantiation of factory automatically sets itself as URLFetcher's factory.
   net::FakeURLFetcherFactory fake_url_fetcher_factory_;
   const GURL test_url_;
   std::unique_ptr<OAuth2TokenService> fake_token_service_;
   UserClassifier user_classifier_;
   NiceMock<MockScheduler> scheduler_;
   std::unique_ptr<FakeContentSuggestionsProviderObserver> observer_;
   CategoryFactory category_factory_;
   NiceMock<MockImageFetcher>* image_fetcher_;
   FakeImageDecoder* image_decoder_;
 
   base::ScopedTempDir database_dir_;
+  MockCaller caller_;
 
   DISALLOW_COPY_AND_ASSIGN(NTPSnippetsServiceTest);
 };
 
 TEST_F(NTPSnippetsServiceTest, ScheduleOnStart) {
   // We should get two |Schedule| calls: The first when initialization
   // completes, the second one after the automatic (since the service doesn't
   // have any data yet) fetch finishes.
   EXPECT_CALL(mock_scheduler(), Schedule(_, _)).Times(2);
   EXPECT_CALL(mock_scheduler(), Unschedule()).Times(0);
@@ skipping 292 matching lines @@
   EXPECT_THAT(service->GetSnippetsForTesting(articles_category()),
               ElementsAre(IdEq(first)));
 
   std::string second("http://second");
   LoadFromJSONString(service.get(), GetTestJson({GetSnippetWithUrl(second)}));
   // The snippets loaded last replace all that was loaded previously.
   EXPECT_THAT(service->GetSnippetsForTesting(articles_category()),
               ElementsAre(IdEq(second)));
 }
 
+TEST_F(NTPSnippetsServiceTest, LoadsAdditionalSnippets) {
+  auto service = MakeSnippetsService();
+
+  std::string first("http://first");
+  LoadFromJSONString(service.get(), GetTestJson({GetSnippetWithUrl(first)}));
+  EXPECT_THAT(service->GetSnippetsForTesting(articles_category()),
+              ElementsAre(IdEq(first)));
+
+  std::string second("http://second");
+  LoadMoreFromJSONString(service.get(),
+                         GetTestJson({GetSnippetWithUrl(second)}),
+                         std::set<std::string>(),
+                         base::Bind([](std::vector<ContentSuggestion>) {}));
+  // The snippets loaded last are added to the previously loaded.
+  EXPECT_THAT(service->GetSnippetsForTesting(articles_category()),
+              ElementsAre(IdEq(first), IdEq(second)));
+}
+
+namespace {
+
+// Workaround for gMock's lack of support for movable types.
+void SuggestionsLoaded(
+    MockFunction<void(const std::vector<ContentSuggestion>& v)>* loaded,
+    std::vector<ContentSuggestion> v) {
+  loaded->Call(v);
+}
+
+}  // namespace
+
+TEST_F(NTPSnippetsServiceTest, InvokesOnlyCallbackOnFetchingMore) {
+  auto service = MakeSnippetsService();
+
+  MockFunction<void(const std::vector<ContentSuggestion>&)> loaded;
+  EXPECT_CALL(loaded, Call(SizeIs(1)));
+
+  LoadMoreFromJSONString(
+      service.get(), GetTestJson({GetSnippetWithUrl("http://some")}),
+      std::set<std::string>(), base::Bind(&SuggestionsLoaded, &loaded));
+
+  // The observer shouldn't have been triggered.
+  EXPECT_THAT(observer().SuggestionsForCategory(articles_category()),
+              IsEmpty());
+}
+
+TEST_F(NTPSnippetsServiceTest, ReturnFetchRequestEmptyBeforeInit) {
+  auto service = MakeSnippetsServiceWithoutInitialization();
+  MockFunction<void(const std::vector<ContentSuggestion>&)> loaded;
+  EXPECT_CALL(loaded, Call(SizeIs(0)));
+  service->Fetch(articles_category(), std::set<std::string>(),
+                 base::Bind(&SuggestionsLoaded, &loaded));
+  base::RunLoop().RunUntilIdle();
+}
+
 TEST_F(NTPSnippetsServiceTest, LoadInvalidJson) {
   auto service = MakeSnippetsService();
 
   LoadFromJSONString(service.get(), GetTestJson({GetInvalidSnippet()}));
   EXPECT_THAT(service->snippets_fetcher()->last_status(),
               StartsWith("Received invalid JSON"));
   EXPECT_THAT(service->GetSnippetsForTesting(articles_category()), IsEmpty());
 }
 
 TEST_F(NTPSnippetsServiceTest, LoadInvalidJsonWithExistingSnippets) {
@@ skipping 451 matching lines @@
         base::StringPrintf("http://localhost/snippet-id-%d", i)));
   }
   LoadFromJSONString(service.get(), GetTestJson(suggestions));
   // TODO(tschumann): We should probably trim out any additional results and
   // only serve the MaxSnippetCount items.
   EXPECT_THAT(service->GetSnippetsForTesting(articles_category()),
               SizeIs(service->GetMaxSnippetCountForTesting() + 1));
 }
 
 }  // namespace ntp_snippets