[NTP::SectionOrder] Propagate new order through ContentSuggestionsService.

components/ntp_snippets/content_suggestions_service_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/content_suggestions_service.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/ntp_snippets/category_info.h"
 #include "components/ntp_snippets/category_rankers/constant_category_ranker.h"
+#include "components/ntp_snippets/category_rankers/mock_category_ranker.h"
 #include "components/ntp_snippets/category_status.h"
 #include "components/ntp_snippets/content_suggestion.h"
 #include "components/ntp_snippets/content_suggestions_provider.h"
 #include "components/ntp_snippets/user_classifier.h"
 #include "components/prefs/testing_pref_service.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/image/image.h"
 
+using testing::_;
 using testing::ElementsAre;
 using testing::Eq;
 using testing::InvokeWithoutArgs;
 using testing::IsEmpty;
 using testing::Mock;
 using testing::Property;
-using testing::_;
+using testing::Return;
+using testing::UnorderedElementsAre;
 
 namespace ntp_snippets {
 
 namespace {
 
 class MockProvider : public ContentSuggestionsProvider {
  public:
   MockProvider(Observer* observer,
                const std::vector<Category>& provided_categories)
       : ContentSuggestionsProvider(observer) {
@@ skipping 78 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockServiceObserver);
 };
 
 }  // namespace
 
 class ContentSuggestionsServiceTest : public testing::Test {
  public:
   ContentSuggestionsServiceTest()
-      : pref_service_(new TestingPrefServiceSimple()) {}
+      : pref_service_(base::MakeUnique<TestingPrefServiceSimple>()),
+        category_ranker_(base::MakeUnique<ConstantCategoryRanker>()) {}
 
   void SetUp() override {
     RegisterPrefs();
     CreateContentSuggestionsService(ContentSuggestionsService::State::ENABLED);
   }
 
   void TearDown() override {
     service_->Shutdown();
     service_.reset();
   }
@@ skipping 41 matching lines @@
 
   MockProvider* RegisterProvider(
       const std::vector<Category>& provided_categories) {
     std::unique_ptr<MockProvider> provider =
         base::MakeUnique<MockProvider>(service(), provided_categories);
     MockProvider* result = provider.get();
     service()->RegisterProvider(std::move(provider));
     return result;
   }
 
+  void SetCategoryRanker(std::unique_ptr<CategoryRanker> category_ranker) {
+    category_ranker_ = std::move(category_ranker);
+  }
+
   MOCK_METHOD1(OnImageFetched, void(const gfx::Image&));
 
  protected:
   void RegisterPrefs() {
     ContentSuggestionsService::RegisterProfilePrefs(pref_service_->registry());
     UserClassifier::RegisterProfilePrefs(pref_service_->registry());
   }
 
   void CreateContentSuggestionsService(
       ContentSuggestionsService::State enabled) {
     ASSERT_FALSE(service_);
-    service_.reset(new ContentSuggestionsService(
+    service_ = base::MakeUnique<ContentSuggestionsService>(
         enabled, /*signin_manager=*/nullptr, /*history_service=*/nullptr,
-        pref_service_.get(),
-        base::MakeUnique<ntp_snippets::ConstantCategoryRanker>()));
+        pref_service_.get(), std::move(category_ranker_));
   }
 
   void ResetService() {
     service_->Shutdown();
     service_.reset();
     CreateContentSuggestionsService(ContentSuggestionsService::State::ENABLED);
   }
 
   ContentSuggestionsService* service() { return service_.get(); }
 
@@ skipping 10 matching lines @@
     std::vector<ContentSuggestion> result;
     for (int number : numbers) {
       result.push_back(CreateSuggestion(category, number));
     }
     return result;
   }
 
  private:
   std::unique_ptr<ContentSuggestionsService> service_;
   std::unique_ptr<TestingPrefServiceSimple> pref_service_;
+  std::unique_ptr<CategoryRanker> category_ranker_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentSuggestionsServiceTest);
 };
 
 class ContentSuggestionsServiceDisabledTest
     : public ContentSuggestionsServiceTest {
  public:
   void SetUp() override {
     RegisterPrefs();
     CreateContentSuggestionsService(ContentSuggestionsService::State::DISABLED);
@@ skipping 13 matching lines @@
               Eq(CategoryStatus::NOT_PROVIDED));
   EXPECT_THAT(service()->GetCategoryStatus(offline_pages_category),
               Eq(CategoryStatus::NOT_PROVIDED));
 
   MockProvider* provider1 = RegisterProvider(articles_category);
   provider1->FireCategoryStatusChangedWithCurrentStatus(articles_category);
   EXPECT_THAT(providers().count(offline_pages_category), Eq(0ul));
   ASSERT_THAT(providers().count(articles_category), Eq(1ul));
   EXPECT_THAT(providers().at(articles_category), Eq(provider1));
   EXPECT_THAT(providers().size(), Eq(1ul));
-  EXPECT_THAT(service()->GetCategories(), ElementsAre(articles_category));
+  EXPECT_THAT(service()->GetCategories(),
+              UnorderedElementsAre(articles_category));
   EXPECT_THAT(service()->GetCategoryStatus(articles_category),
               Eq(CategoryStatus::AVAILABLE));
   EXPECT_THAT(service()->GetCategoryStatus(offline_pages_category),
               Eq(CategoryStatus::NOT_PROVIDED));
 
   MockProvider* provider2 = RegisterProvider(offline_pages_category);
   provider2->FireCategoryStatusChangedWithCurrentStatus(offline_pages_category);
   ASSERT_THAT(providers().count(offline_pages_category), Eq(1ul));
   EXPECT_THAT(providers().at(articles_category), Eq(provider1));
   ASSERT_THAT(providers().count(articles_category), Eq(1ul));
   EXPECT_THAT(providers().at(offline_pages_category), Eq(provider2));
   EXPECT_THAT(providers().size(), Eq(2ul));
   EXPECT_THAT(service()->GetCategories(),
-              ElementsAre(offline_pages_category, articles_category));
+              UnorderedElementsAre(offline_pages_category, articles_category));
   EXPECT_THAT(service()->GetCategoryStatus(articles_category),
               Eq(CategoryStatus::AVAILABLE));
   EXPECT_THAT(service()->GetCategoryStatus(offline_pages_category),
               Eq(CategoryStatus::AVAILABLE));
 }
 
 TEST_F(ContentSuggestionsServiceDisabledTest, ShouldDoNothingWhenDisabled) {
   Category articles_category =
       Category::FromKnownCategory(KnownCategories::ARTICLES);
   Category offline_pages_category =
@@ skipping 239 matching lines @@
                                                 CategoryStatus::INITIALIZING));
   provider->FireCategoryStatusChanged(new_category,
                                       CategoryStatus::INITIALIZING);
 
   ASSERT_THAT(providers().count(new_category), Eq(1ul));
   EXPECT_THAT(providers().at(new_category), Eq(provider));
   ExpectThatSuggestionsAre(new_category, std::vector<int>());
   EXPECT_THAT(service()->GetCategoryStatus(new_category),
               Eq(CategoryStatus::INITIALIZING));
   EXPECT_THAT(service()->GetCategories(),
-              Eq(std::vector<Category>({category, new_category})));
+              UnorderedElementsAre(category, new_category));
 
   service()->RemoveObserver(&observer);
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldRemoveCategoryWhenNotProvided) {
   Category category = Category::FromKnownCategory(KnownCategories::DOWNLOADS);
   MockProvider* provider = RegisterProvider(category);
   MockServiceObserver observer;
   service()->AddObserver(&observer);
 
@@ skipping 32 matching lines @@
   service()->Fetch(category, known_suggestions, FetchDoneCallback());
 }
 
 TEST_F(ContentSuggestionsServiceTest, DismissAndRestoreCategory) {
   // Register a category with one suggestion.
   Category category = Category::FromKnownCategory(KnownCategories::ARTICLES);
   MockProvider* provider = RegisterProvider(category);
   provider->FireCategoryStatusChangedWithCurrentStatus(category);
   provider->FireSuggestionsChanged(category, CreateSuggestions(category, {42}));
 
-  EXPECT_THAT(service()->GetCategories(), ElementsAre(category));
+  EXPECT_THAT(service()->GetCategories(), UnorderedElementsAre(category));
   EXPECT_THAT(service()->GetCategoryStatus(category),
               Eq(CategoryStatus::AVAILABLE));
   ExpectThatSuggestionsAre(category, {42});
   EXPECT_THAT(providers().count(category), Eq(1ul));
   EXPECT_THAT(dismissed_providers(), IsEmpty());
 
   // Dismissing the category clears the suggestions for it.
   service()->DismissCategory(category);
 
   EXPECT_THAT(service()->GetCategories(), IsEmpty());
   EXPECT_THAT(service()->GetCategoryStatus(category),
               Eq(CategoryStatus::NOT_PROVIDED));
   EXPECT_THAT(service()->GetSuggestionsForCategory(category), IsEmpty());
   EXPECT_THAT(providers(), IsEmpty());
   EXPECT_THAT(dismissed_providers().count(category), Eq(1ul));
 
   // Restoring the dismissed category makes it available again but it is still
   // empty.
   service()->RestoreDismissedCategories();
 
-  EXPECT_THAT(service()->GetCategories(), ElementsAre(category));
+  EXPECT_THAT(service()->GetCategories(), UnorderedElementsAre(category));
   EXPECT_THAT(service()->GetCategoryStatus(category),
               Eq(CategoryStatus::AVAILABLE));
   EXPECT_THAT(service()->GetSuggestionsForCategory(category), IsEmpty());
   EXPECT_THAT(providers().count(category), Eq(1ul));
   EXPECT_THAT(dismissed_providers(), IsEmpty());
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldRestoreDismissedCategories) {
   // Create and register provider.
   Category category1 = Category::FromIDValue(1);
@@ skipping 65 matching lines @@
   // restoration.
   provider = RegisterProvider(category);
   provider->FireCategoryStatusChangedWithCurrentStatus(category);
   EXPECT_TRUE(service()->IsCategoryDismissed(category));
 
   service()->RestoreDismissedCategories();
   EXPECT_FALSE(service()->IsCategoryDismissed(category));
   EXPECT_THAT(providers().find(category)->second, Eq(provider));
 }
 
+TEST_F(ContentSuggestionsServiceTest, ShouldReturnCategoriesInOrderToDisplay) {
+  auto mock_ranker = base::MakeUnique<MockCategoryRanker>();
+  MockCategoryRanker* raw_mock_ranker = mock_ranker.get();
+  SetCategoryRanker(std::move(mock_ranker));
+  // The service is recreated to pick up a new ranker.
+  ResetService();
+
+  const Category first_category = Category::FromRemoteCategory(1);
+  const Category second_category = Category::FromRemoteCategory(2);
+
+  MockProvider* provider = RegisterProvider({first_category, second_category});
+  provider->FireCategoryStatusChangedWithCurrentStatus(first_category);
+  provider->FireCategoryStatusChangedWithCurrentStatus(second_category);
+
+  EXPECT_CALL(*raw_mock_ranker, Compare(first_category, second_category))
+      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*raw_mock_ranker, Compare(second_category, first_category))
+      .WillRepeatedly(Return(false));
+
+  EXPECT_THAT(service()->GetCategories(),
+              ElementsAre(first_category, second_category));
+
+  // The order to display (in the ranker) changes.
+  EXPECT_CALL(*raw_mock_ranker, Compare(first_category, second_category))
+      .WillRepeatedly(Return(false));
+  EXPECT_CALL(*raw_mock_ranker, Compare(second_category, first_category))
+      .WillRepeatedly(Return(true));
+  // Categories order should reflect the new order.
+  EXPECT_THAT(service()->GetCategories(),
+              ElementsAre(second_category, first_category));
+}
+
 }  // namespace ntp_snippets