[Remote suggestions] Move the throttler into the Scheduler

components/ntp_snippets/remote/scheduling_remote_suggestions_provider_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 "components/ntp_snippets/remote/scheduling_remote_suggestions_provider.h"
 
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 80 matching lines @@
   MOCK_METHOD1(GetCategoryStatus, CategoryStatus(Category));
   MOCK_METHOD1(GetCategoryInfo, CategoryInfo(Category));
   MOCK_METHOD3(ClearHistory,
                void(base::Time begin,
                     base::Time end,
                     const base::Callback<bool(const GURL& url)>& filter));
   MOCK_METHOD3(Fetch,
                void(const Category&,
                     const std::set<std::string>&,
                     const FetchDoneCallback&));
+  MOCK_METHOD0(ReloadSuggestions, void());
   MOCK_METHOD1(ClearCachedSuggestions, void(Category));
   MOCK_METHOD1(ClearDismissedSuggestionsForDebugging, void(Category));
   MOCK_METHOD1(DismissSuggestion, void(const ContentSuggestion::ID&));
   MOCK_METHOD2(FetchSuggestionImage,
                void(const ContentSuggestion::ID&, const ImageFetchedCallback&));
   MOCK_METHOD2(GetDismissedSuggestionsForDebugging,
                void(Category, const DismissedSuggestionsCallback&));
   MOCK_METHOD0(OnSignInStateChanged, void());
 };
 
 }  // namespace
 
 class SchedulingRemoteSuggestionsProviderTest
     : public ::testing::Test {
  public:
   SchedulingRemoteSuggestionsProviderTest()
       :  // For the test we enabled all trigger types.
         default_variation_params_{{"scheduler_trigger_types",
                                    "persistent_scheduler_wake_up,ntp_opened,"
                                    "browser_foregrounded,browser_cold_start"}},
         params_manager_(ntp_snippets::kStudyName,
                         default_variation_params_,
                         {kArticleSuggestionsFeature.name}),
         underlying_provider_(nullptr),
         scheduling_provider_(nullptr),
         user_classifier_(/*pref_service=*/nullptr) {
     SchedulingRemoteSuggestionsProvider::RegisterProfilePrefs(
         utils_.pref_service()->registry());
+    RequestThrottler::RegisterProfilePrefs(utils_.pref_service()->registry());
     ResetProvider();
   }
 
   void ResetProvider() {
     auto underlying_provider =
         base::MakeUnique<StrictMock<MockRemoteSuggestionsProvider>>(
             /*observer=*/nullptr);
     underlying_provider_ = underlying_provider.get();
 
     // SchedulingRemoteSuggestionsProvider calls
@@ skipping 531 matching lines @@
   EXPECT_CALL(persistent_scheduler_, Schedule(_, _));
   signal_fetch_done.Run(Status::Success());
 
   // Clear the suggestions.
   scheduling_provider_->OnSuggestionsCleared();
   // Another trigger right after results in a fetch again.
   EXPECT_CALL(*underlying_provider_, RefetchInTheBackground(_));
   scheduling_provider_->OnBrowserForegrounded();
 }
 
+TEST_F(SchedulingRemoteSuggestionsProviderTest,
+       ShouldThrottleInteractiveRequests) {
+  // Change the quota for interactive requests ("active NTP user" is the default
+  // class in tests).
+  SetVariationParameter("interactive_quota_SuggestionFetcherActiveNTPUser",
+                        "10");
+  ResetProvider();
+
+  Category category = Category::FromKnownCategory(KnownCategories::ARTICLES);
+  std::set<std::string> known_suggestions;
+
+  // As long as the quota suffices, the call gets through.

[Marc Treib, 2017/02/24 15:50:35]

Maybe mention that both ReloadSuggestions and Fetch consume quota? Took me a bit
to figure this out.
(Also, is there any reason to interleave the calls? It kinda seems to me like
we're testing two different things here, but I might be missing something.)

[jkrcal, 2017/02/27 10:26:23]

Added a comment. The reason to mix these two is to test that they consume the
same quota (and that the consumption adds up).

+  EXPECT_CALL(*underlying_provider_, ReloadSuggestions()).Times(5);
+  EXPECT_CALL(*underlying_provider_, Fetch(_, _, _)).Times(5);
+  for (int x = 0; x < 5; ++x) {
+    scheduling_provider_->ReloadSuggestions();
+    scheduling_provider_->Fetch(category, known_suggestions,
+                                FetchDoneCallback());
+  }
+
+  // When the quota expires, it is blocked by the scheduling provider.
+  scheduling_provider_->ReloadSuggestions();
+  scheduling_provider_->Fetch(category, known_suggestions, FetchDoneCallback());

[tschumann, 2017/02/24 10:18:08]

shouldn't we verify the result codes?

[jkrcal, 2017/02/27 10:26:23]

Done.

+}
+
+TEST_F(SchedulingRemoteSuggestionsProviderTest,
+       ShouldThrottleNonInteractiveRequests) {
+  // Change the quota for interactive requests ("active NTP user" is the default
+  // class in tests).
+  SetVariationParameter("quota_SuggestionFetcherActiveNTPUser", "5");
+  ResetProvider();
+
+  // One scheduling on start, 5 times after successful fetches.
+  EXPECT_CALL(persistent_scheduler_, Schedule(_, _)).Times(6);
+
+  // First enable the scheduler -- this will trigger the persistent scheduling.
+  ActivateUnderlyingProvider();
+
+  // As long as the quota suffices, the call gets through.
+  RemoteSuggestionsProvider::FetchStatusCallback signal_fetch_done;
+  EXPECT_CALL(*underlying_provider_, RefetchInTheBackground(_))
+      .Times(5)
+      .WillRepeatedly(SaveArg<0>(&signal_fetch_done));
+  for (int x = 0; x < 5; ++x) {
+    scheduling_provider_->OnPersistentSchedulerWakeUp();
+    signal_fetch_done.Run(Status::Success());
+  }
+
+  // For the 6th time, it is blocked by the scheduling provider.
+  scheduling_provider_->OnPersistentSchedulerWakeUp();
+}
+
 }  // namespace ntp_snippets