[NTP::SectionOrder] Make dismissed category penalty a variation param.

components/ntp_snippets/category_rankers/click_based_category_ranker_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/category_rankers/click_based_category_ranker.h"
 
 #include "base/memory/ptr_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/test/simple_test_clock.h"
 #include "base/time/default_clock.h"
 #include "base/time/time.h"
 #include "components/ntp_snippets/category.h"
 #include "components/ntp_snippets/category_rankers/constant_category_ranker.h"
+#include "components/ntp_snippets/features.h"
+#include "components/ntp_snippets/ntp_snippets_constants.h"
 #include "components/prefs/testing_pref_service.h"
+#include "components/variations/variations_params_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace ntp_snippets {
 
 class ClickBasedCategoryRankerTest : public testing::Test {
  public:
   ClickBasedCategoryRankerTest()
       : pref_service_(base::MakeUnique<TestingPrefServiceSimple>()),
         unused_remote_category_id_(
@@ skipping 34 matching lines @@
   void NotifyOnSuggestionOpened(int times, Category category) {
     for (int i = 0; i < times; ++i) {
       ranker()->OnSuggestionOpened(category);
     }
   }
 
   void NotifyOnCategoryDismissed(Category category) {
     ranker()->OnCategoryDismissed(category);
   }
 
+  void SetDismissedCategoryPenaltyVariationParam(int value) {
+    variation_params_manager_.SetVariationParamsWithFeatureAssociations(
+        ntp_snippets::kStudyName,
+        {{"click_based_category_ranker-dismissed_category_penalty",
+          base::IntToString(value)}},
+        {kCategoryRanker.name});
+  }
+
   ClickBasedCategoryRanker* ranker() { return ranker_.get(); }
 
  private:
   std::unique_ptr<TestingPrefServiceSimple> pref_service_;
   int unused_remote_category_id_;
   std::unique_ptr<ClickBasedCategoryRanker> ranker_;
+  variations::testing::VariationParamsManager variation_params_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(ClickBasedCategoryRankerTest);
 };
 
 TEST_F(ClickBasedCategoryRankerTest, ShouldSortRemoteCategoriesByWhenAdded) {
   const Category first = GetUnusedRemoteCategory();
   const Category second = GetUnusedRemoteCategory();
   // Categories are added in decreasing id order to test that they are not
   // compared by id.
   ranker()->AppendCategoryIfNecessary(second);
@@ skipping 233 matching lines @@
 
   // Ensure that |Now()| is different from |before| by injecting our clock.
   auto test_clock = base::MakeUnique<base::SimpleTestClock>();
   test_clock->SetNow(base::Time::Now() + base::TimeDelta::FromSeconds(10));
   ResetRanker(std::move(test_clock));
 
   EXPECT_EQ(before, ranker()->GetLastDecayTime());
 }
 
 TEST_F(ClickBasedCategoryRankerTest, ShouldMoveCategoryDownWhenDismissed) {
+  SetDismissedCategoryPenaltyVariationParam(2);
+
   // Take top categories.
   std::vector<KnownCategories> default_order =
       ConstantCategoryRanker::GetKnownCategoriesDefaultOrder();
   Category first = Category::FromKnownCategory(default_order[0]);
   Category second = Category::FromKnownCategory(default_order[1]);
 
   ASSERT_TRUE(CompareCategories(first, second));
   NotifyOnCategoryDismissed(first);
   EXPECT_FALSE(CompareCategories(first, second));
 }
 
 TEST_F(ClickBasedCategoryRankerTest,
        ShouldMoveSecondToLastCategoryDownWhenDismissed) {
+  SetDismissedCategoryPenaltyVariationParam(2);
+
   // Add categories to the bottom.
   Category first = AddUnusedRemoteCategory();
   Category second = AddUnusedRemoteCategory();
 
   ASSERT_TRUE(CompareCategories(first, second));
   NotifyOnCategoryDismissed(first);
   EXPECT_FALSE(CompareCategories(first, second));
 }
 
 TEST_F(ClickBasedCategoryRankerTest,
        ShouldNotMoveCategoryTooMuchDownWhenDismissed) {
+  SetDismissedCategoryPenaltyVariationParam(2);
+
   // Add enough categories to the end.
   std::vector<Category> categories;
   const int penalty = ClickBasedCategoryRanker::GetDismissedCategoryPenalty();
   for (int i = 0; i < 2 * penalty + 10; ++i) {
     categories.push_back(AddUnusedRemoteCategory());
   }
 
   const int target = penalty + 1;
   Category target_category = categories[target];
   for (int i = 0; i < static_cast<int>(categories.size()); ++i) {
     ASSERT_EQ(i < target, CompareCategories(categories[i], target_category));
   }
 
   // This should move exactly |penalty| categories up.
   NotifyOnCategoryDismissed(categories[target]);
 
   // Reflect expected change in |categories|.
   const int expected = target + penalty;
   for (int i = target; i + 1 <= expected; ++i) {
     std::swap(categories[i], categories[i + 1]);
   }
 
   for (int i = 0; i < static_cast<int>(categories.size()); ++i) {
     EXPECT_EQ(i < expected, CompareCategories(categories[i], target_category));
   }
 }
 
 TEST_F(ClickBasedCategoryRankerTest,
        ShouldNotChangeOrderOfOtherCategoriesWhenDismissed) {
+  SetDismissedCategoryPenaltyVariationParam(2);
+
   // Add enough categories to the end.
   std::vector<Category> categories;
   const int penalty = ClickBasedCategoryRanker::GetDismissedCategoryPenalty();
   for (int i = 0; i < 2 * penalty + 10; ++i) {
     categories.push_back(AddUnusedRemoteCategory());
   }
 
   int target = penalty + 1;
   // This should not change order of all other categories.
   NotifyOnCategoryDismissed(categories[target]);
 
   categories.erase(categories.begin() + target);
   for (int first = 0; first < static_cast<int>(categories.size()); ++first) {
     for (int second = 0; second < static_cast<int>(categories.size());
          ++second) {
       EXPECT_EQ(first < second,
                 CompareCategories(categories[first], categories[second]));
     }
   }
 }
 
 TEST_F(ClickBasedCategoryRankerTest, ShouldNotMoveLastCategoryWhenDismissed) {
+  SetDismissedCategoryPenaltyVariationParam(2);
+
   Category first = AddUnusedRemoteCategory();
   Category second = AddUnusedRemoteCategory();
 
   ASSERT_TRUE(CompareCategories(first, second));
   NotifyOnCategoryDismissed(second);
   EXPECT_TRUE(CompareCategories(first, second));
 }
 
 TEST_F(ClickBasedCategoryRankerTest,
        ShouldReduceLastCategoryClicksWhenDismissed) {
+  SetDismissedCategoryPenaltyVariationParam(2);
+
   Category first = AddUnusedRemoteCategory();
   Category second = AddUnusedRemoteCategory();
 
   ASSERT_TRUE(CompareCategories(first, second));
 
   NotifyOnSuggestionOpened(
       /*times=*/1, second);
 
   // This should reduce the click count back to 0.
   NotifyOnCategoryDismissed(second);
 
   // Try to move the second category up assuming that the previous click is
   // still there.
   NotifyOnSuggestionOpened(
       /*times=*/ClickBasedCategoryRanker::GetPassingMargin() - 1, second);
 
   EXPECT_TRUE(CompareCategories(first, second));
 
   NotifyOnSuggestionOpened(
       /*times=*/1, second);
   EXPECT_FALSE(CompareCategories(first, second));
 }
 
+TEST_F(ClickBasedCategoryRankerTest,
+       ShouldTakeVariationValueForDismissedCategoryPenalty) {
+  const int penalty = 10203;
+  SetDismissedCategoryPenaltyVariationParam(penalty);
+  EXPECT_EQ(penalty, ClickBasedCategoryRanker::GetDismissedCategoryPenalty());
+}
+
+TEST_F(ClickBasedCategoryRankerTest,
+       ShouldDoNothingWhenCategoryDismissedIfPenaltyIsZero) {
+  SetDismissedCategoryPenaltyVariationParam(0);
+
+  // Add dummy remote categories to ensure that the following categories are not
+  // in the top anymore.
+  AddUnusedRemoteCategories(
+      ClickBasedCategoryRanker::GetNumTopCategoriesWithExtraMargin());
+
+  Category first = AddUnusedRemoteCategory();
+  Category second = AddUnusedRemoteCategory();
+  Category third = AddUnusedRemoteCategory();
+
+  NotifyOnSuggestionOpened(
+      /*times=*/1, second);
+
+  // This should be ignored, because the penalty is set to 0.
+  NotifyOnCategoryDismissed(second);
+
+  // The second category should stay where it was.
+  EXPECT_TRUE(CompareCategories(first, second));
+  EXPECT_TRUE(CompareCategories(second, third));
+
+  // Try to move the second category up assuming that the previous click is
+  // still there.
+  NotifyOnSuggestionOpened(
+      /*times=*/ClickBasedCategoryRanker::GetPassingMargin() - 1, second);
+
+  // It should overtake the first category, because the dismissal should be
+  // ignored and the click should remain.
+  EXPECT_FALSE(CompareCategories(first, second));
+}
+
 TEST_F(ClickBasedCategoryRankerTest, ShouldRestoreDefaultOrderOnClearHistory) {
   std::vector<KnownCategories> default_order =
       ConstantCategoryRanker::GetKnownCategoriesDefaultOrder();
   Category first = Category::FromKnownCategory(default_order[0]);
   Category second = Category::FromKnownCategory(default_order[1]);
 
   ASSERT_TRUE(CompareCategories(first, second));
 
   // Change the order.
   while (CompareCategories(first, second)) {
@@ skipping 43 matching lines @@
   // The user partially clears history.
   base::Time begin = base::Time::Now() - base::TimeDelta::FromHours(1),
              end = base::Time::Max();
   ranker()->ClearHistory(begin, end);
 
   // The order should not be cleared.
   EXPECT_FALSE(CompareCategories(first, second));
 }
 
 }  // namespace ntp_snippets