[Background fetching] Configure and report fetching triggers

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 102 matching lines @@
                void(Category, const DismissedSuggestionsCallback&));
   MOCK_METHOD0(OnSignInStateChanged, void());
 };
 
 }  // namespace
 
 class SchedulingRemoteSuggestionsProviderTest
     : public ::testing::Test {
  public:
   SchedulingRemoteSuggestionsProviderTest()
-      : underlying_provider_(nullptr),
+      :  // 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());
+    ResetProvider();
+  }
 
+  void ResetProvider() {
     auto underlying_provider =
         base::MakeUnique<StrictMock<MockRemoteSuggestionsProvider>>(
             /*observer=*/nullptr);
     underlying_provider_ = underlying_provider.get();
 
     // SchedulingRemoteSuggestionsProvider calls SetProviderStatusCallback(_) to
     // stay in the loop of status changes.
     EXPECT_CALL(*underlying_provider_, SetProviderStatusCallback(_))
         .WillOnce(SaveArg<0>(&provider_status_callback_));
 
     auto test_clock = base::MakeUnique<base::SimpleTestClock>();
     test_clock_ = test_clock.get();
     test_clock_->SetNow(base::Time::Now());
 
     scheduling_provider_ =
         base::MakeUnique<SchedulingRemoteSuggestionsProvider>(
             /*observer=*/nullptr, std::move(underlying_provider),
             &persistent_scheduler_, &user_classifier_, utils_.pref_service(),
             std::move(test_clock));
   }
 
+  void SetVariationParameter(const std::string& param_name,
+                             const std::string& param_value) {
+    std::map<std::string, std::string> params = default_variation_params_;
+    params[param_name] = param_value;
+
+    params_manager_.ClearAllVariationParams();
+    params_manager_.SetVariationParamsWithFeatureAssociations(
+        ntp_snippets::kStudyName, params,
+        {ntp_snippets::kArticleSuggestionsFeature.name});
+  }
+
  protected:
+  std::map<std::string, std::string> default_variation_params_;
+  variations::testing::VariationParamsManager params_manager_;
   StrictMock<MockPersistentScheduler> persistent_scheduler_;
   StrictMock<MockRemoteSuggestionsProvider>* underlying_provider_;
   std::unique_ptr<SchedulingRemoteSuggestionsProvider> scheduling_provider_;
   RemoteSuggestionsProvider::ProviderStatusCallback provider_status_callback_;
   base::SimpleTestClock* test_clock_;
 
   void ChangeStatusOfUnderlyingProvider(
       RemoteSuggestionsProvider::ProviderStatus new_status) {
     provider_status_callback_.Run(new_status);
   }
 
  private:
   test::RemoteSuggestionsTestUtils utils_;
   UserClassifier user_classifier_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulingRemoteSuggestionsProviderTest);
 };
 
 TEST_F(SchedulingRemoteSuggestionsProviderTest,
        ShouldIgnoreSignalsWhenNotEnabled) {
   scheduling_provider_->OnPersistentSchedulerWakeUp();
   scheduling_provider_->OnNTPOpened();
+  scheduling_provider_->OnBrowserForegrounded();
+  scheduling_provider_->OnBrowserColdStart();
+}
+
+TEST_F(SchedulingRemoteSuggestionsProviderTest,
+       ShouldIgnoreSignalsWhenDisabledByParam) {
+  // First set an empty list of allowed trigger types.
+  SetVariationParameter("scheduler_trigger_types", "-");
+  ResetProvider();
+
+  // Then enable the scheduler.
+  EXPECT_CALL(persistent_scheduler_, Schedule(_, _));
+  ChangeStatusOfUnderlyingProvider(
+      RemoteSuggestionsProvider::ProviderStatus::ACTIVE);
+
+  scheduling_provider_->OnPersistentSchedulerWakeUp();
+  scheduling_provider_->OnNTPOpened();
+  scheduling_provider_->OnBrowserForegrounded();
+  scheduling_provider_->OnBrowserColdStart();
+}
+
+TEST_F(SchedulingRemoteSuggestionsProviderTest,
+       ShouldHandleEmptyParamForTriggerTypes) {
+  // First set an empty param for allowed trigger types -> should result in the
+  // default list.
+  SetVariationParameter("scheduler_trigger_types", "");
+  ResetProvider();
+
+  // Then enable the scheduler.
+  EXPECT_CALL(persistent_scheduler_, Schedule(_, _));
+  ChangeStatusOfUnderlyingProvider(
+      RemoteSuggestionsProvider::ProviderStatus::ACTIVE);
+
+  // For instance, persistent scheduler wake up should be enabled by default.
+  EXPECT_CALL(*underlying_provider_, RefetchInTheBackground(_));
+  scheduling_provider_->OnPersistentSchedulerWakeUp();
+}
+
+TEST_F(SchedulingRemoteSuggestionsProviderTest,
+       ShouldHandleIncorrentParamForTriggerTypes) {
+  // First set an invalid list of allowed trigger types.
+  SetVariationParameter("scheduler_trigger_types", "ntp_opened,foo;");
+  ResetProvider();
+
+  // Then enable the scheduler.
+  EXPECT_CALL(persistent_scheduler_, Schedule(_, _));
+  ChangeStatusOfUnderlyingProvider(
+      RemoteSuggestionsProvider::ProviderStatus::ACTIVE);
+
+  // For instance, persistent scheduler wake up should be enabled by default.
+  EXPECT_CALL(*underlying_provider_, RefetchInTheBackground(_));
+  scheduling_provider_->OnPersistentSchedulerWakeUp();
 }
 
 TEST_F(SchedulingRemoteSuggestionsProviderTest,
        ShouldFetchOnPersistentSchedulerWakeUp) {
-  // First enable the scheduler.
+  // First set only this type to be allowed.
+  SetVariationParameter("scheduler_trigger_types",
+                        "persistent_scheduler_wake_up");
+  ResetProvider();
+
+  // Then enable the scheduler.
   EXPECT_CALL(persistent_scheduler_, Schedule(_, _));
   ChangeStatusOfUnderlyingProvider(
       RemoteSuggestionsProvider::ProviderStatus::ACTIVE);
 
   EXPECT_CALL(*underlying_provider_, RefetchInTheBackground(_));
   scheduling_provider_->OnPersistentSchedulerWakeUp();
 }
 
 TEST_F(SchedulingRemoteSuggestionsProviderTest,
        ShouldFetchOnPersistentSchedulerWakeUpRepeated) {
@@ skipping 28 matching lines @@
   ChangeStatusOfUnderlyingProvider(
       RemoteSuggestionsProvider::ProviderStatus::ACTIVE);
   // Make the first persistent fetch never finish.
   scheduling_provider_->OnPersistentSchedulerWakeUp();
   // Make the second fetch.
   scheduling_provider_->OnPersistentSchedulerWakeUp();
 }
 
 TEST_F(SchedulingRemoteSuggestionsProviderTest,
        ShouldFetchOnNTPOpenedForTheFirstTime) {
-  // First enable the scheduler.
+  // First set only this type to be allowed.
+  SetVariationParameter("scheduler_trigger_types", "ntp_opened");
+  ResetProvider();
+
+  // Then enable the scheduler.
   EXPECT_CALL(persistent_scheduler_, Schedule(_, _));
   ChangeStatusOfUnderlyingProvider(
       RemoteSuggestionsProvider::ProviderStatus::ACTIVE);
 
   EXPECT_CALL(*underlying_provider_, RefetchInTheBackground(_));
   scheduling_provider_->OnNTPOpened();
 }
 
 TEST_F(SchedulingRemoteSuggestionsProviderTest,
+       ShouldFetchOnBrowserForegroundedForTheFirstTime) {
+  // First set only this type to be allowed.
+  SetVariationParameter("scheduler_trigger_types", "browser_foregrounded");
+  ResetProvider();
+
+  // Then enable the scheduler.
+  EXPECT_CALL(persistent_scheduler_, Schedule(_, _));
+  ChangeStatusOfUnderlyingProvider(
+      RemoteSuggestionsProvider::ProviderStatus::ACTIVE);
+
+  EXPECT_CALL(*underlying_provider_, RefetchInTheBackground(_));
+  scheduling_provider_->OnBrowserForegrounded();
+}
+
+TEST_F(SchedulingRemoteSuggestionsProviderTest,
+       ShouldFetchOnBrowserColdStartForTheFirstTime) {
+  // First set only this type to be allowed.
+  SetVariationParameter("scheduler_trigger_types", "browser_cold_start");
+  ResetProvider();
+
+  // Then enable the scheduler.
+  EXPECT_CALL(persistent_scheduler_, Schedule(_, _));
+  ChangeStatusOfUnderlyingProvider(
+      RemoteSuggestionsProvider::ProviderStatus::ACTIVE);
+
+  EXPECT_CALL(*underlying_provider_, RefetchInTheBackground(_));
+  scheduling_provider_->OnBrowserColdStart();
+}
+
+TEST_F(SchedulingRemoteSuggestionsProviderTest,
        ShouldNotFetchOnNTPOpenedAfterSuccessfulSoftFetch) {
   // First enable the scheduler; the second Schedule is called after the
   // successful fetch.
   EXPECT_CALL(persistent_scheduler_, Schedule(_, _)).Times(2);
   ChangeStatusOfUnderlyingProvider(
       RemoteSuggestionsProvider::ProviderStatus::ACTIVE);
 
   // Make the first soft fetch successful.
   RemoteSuggestionsProvider::FetchStatusCallback signal_fetch_done;
   EXPECT_CALL(*underlying_provider_, RefetchInTheBackground(_))
@@ skipping 180 matching lines @@
 }
 
 TEST_F(SchedulingRemoteSuggestionsProviderTest,
        ReschedulesWhenWifiParamChanges) {
   EXPECT_CALL(persistent_scheduler_, Schedule(_, _)).Times(2);
   ChangeStatusOfUnderlyingProvider(
       RemoteSuggestionsProvider::ProviderStatus::ACTIVE);
 
   // UserClassifier defaults to UserClass::ACTIVE_NTP_USER if PrefService is
   // null. Change the wifi interval for this class.
-  variations::testing::VariationParamsManager params_manager(
-      ntp_snippets::kStudyName,
-      {{"fetching_interval_hours-wifi-active_ntp_user", "1.5"}},
-      {kArticleSuggestionsFeature.name});
+  SetVariationParameter("fetching_interval_hours-wifi-active_ntp_user", "1.5");
 
   // Schedule() should get called for the second time after params have changed.
   ChangeStatusOfUnderlyingProvider(
       RemoteSuggestionsProvider::ProviderStatus::ACTIVE);
 }
 
 TEST_F(SchedulingRemoteSuggestionsProviderTest,
        ReschedulesWhenFallbackParamChanges) {
   EXPECT_CALL(persistent_scheduler_, Schedule(_, _)).Times(2);
   ChangeStatusOfUnderlyingProvider(
       RemoteSuggestionsProvider::ProviderStatus::ACTIVE);
 
   // UserClassifier defaults to UserClass::ACTIVE_NTP_USER if PrefService is
-  // null. Change the wifi interval for this class.
-  variations::testing::VariationParamsManager params_manager(
-      ntp_snippets::kStudyName,
-      {{"fetching_interval_hours-fallback-active_ntp_user", "1.5"}},
-      {kArticleSuggestionsFeature.name});
+  // null. Change the fallback interval for this class.
+  SetVariationParameter("fetching_interval_hours-fallback-active_ntp_user",
+                        "1.5");
 
   // Schedule() should get called for the second time after params have changed.
   ChangeStatusOfUnderlyingProvider(
       RemoteSuggestionsProvider::ProviderStatus::ACTIVE);
 }
 
 TEST_F(SchedulingRemoteSuggestionsProviderTest,
        ReschedulesWhenOnUsageEventParamChanges) {
   EXPECT_CALL(persistent_scheduler_, Schedule(_, _)).Times(2);
   ChangeStatusOfUnderlyingProvider(
       RemoteSuggestionsProvider::ProviderStatus::ACTIVE);
 
   // UserClassifier defaults to UserClass::ACTIVE_NTP_USER if PrefService is
-  // null. Change the wifi interval for this class.
-  variations::testing::VariationParamsManager params_manager(
-      ntp_snippets::kStudyName,
-      {{"soft_fetching_interval_hours-active-active_ntp_user", "1.5"}},
-      {kArticleSuggestionsFeature.name});
+  // null. Change the on usage interval for this class.
+  SetVariationParameter("soft_fetching_interval_hours-active-active_ntp_user",
+                        "1.5");
 
   // Schedule() should get called for the second time after params have changed.
   ChangeStatusOfUnderlyingProvider(
       RemoteSuggestionsProvider::ProviderStatus::ACTIVE);
 }
 
 }  // namespace ntp_snippets