📰 Tweak the suggestion ranks for UMA to handle fetchMore

chrome/android/junit/src/org/chromium/chrome/browser/ntp/cards/NewTabPageAdapterTest.java

 // 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.
 
 package org.chromium.chrome.browser.ntp.cards;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertThat;
@@ skipping 49 matching lines @@
 import org.chromium.chrome.browser.ntp.snippets.CategoryInt;
 import org.chromium.chrome.browser.ntp.snippets.CategoryStatus;
 import org.chromium.chrome.browser.ntp.snippets.FakeSuggestionsSource;
 import org.chromium.chrome.browser.ntp.snippets.KnownCategories;
 import org.chromium.chrome.browser.ntp.snippets.SnippetArticle;
 import org.chromium.chrome.browser.offlinepages.OfflinePageBridge;
 import org.chromium.chrome.browser.preferences.ChromePreferenceManager;
 import org.chromium.chrome.browser.signin.SigninManager;
 import org.chromium.chrome.browser.signin.SigninManager.SignInAllowedObserver;
 import org.chromium.chrome.browser.signin.SigninManager.SignInStateObserver;
+import org.chromium.chrome.browser.suggestions.SuggestionsMetricsReporter;
 import org.chromium.testing.local.LocalRobolectricTestRunner;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
 
 /**
  * Unit tests for {@link NewTabPageAdapter}.
@@ skipping 123 matching lines @@
         RecordUserAction.disableForTests();
 
         @CategoryInt
         final int category = KnownCategories.ARTICLES;
         mSource = new FakeSuggestionsSource();
         mSource.setStatusForCategory(category, CategoryStatus.INITIALIZING);
         mSource.setInfoForCategory(category,
                 new CategoryInfoBuilder(category).showIfEmpty().build());
 
         when(mNewTabPageManager.getSuggestionsSource()).thenReturn(mSource);
+        when(mNewTabPageManager.getSuggestionsMetricsReporter())
+                .thenReturn(mock(SuggestionsMetricsReporter.class));
         when(mNewTabPageManager.isCurrentPage()).thenReturn(true);
 
         reloadNtp();
     }
 
     @After
     public void tearDown() {
         SigninManager.setInstanceForTesting(null);
         ChromePreferenceManager.getInstance(RuntimeEnvironment.application)
                 .setNewTabPageSigninPromoDismissed(false);
     }
 
     /**
      * Tests the content of the adapter under standard conditions: on start and after a suggestions
      * fetch.
      */
     @Test
     @Feature({"Ntp"})
     public void testSuggestionLoading() {
         assertItemsFor(sectionWithStatusCard().withProgress());
 
         final int numSuggestions = 3;
-        List<SnippetArticle> suggestions = createDummySuggestions(numSuggestions);
+        List<SnippetArticle> suggestions =
+                createDummySuggestions(numSuggestions, KnownCategories.ARTICLES);
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.AVAILABLE);
         mSource.setSuggestionsForCategory(KnownCategories.ARTICLES, suggestions);
 
         assertItemsFor(section(numSuggestions));
     }
 
     /**
      * Tests that the adapter keeps listening for suggestion updates.
      */
     @Test
     @Feature({"Ntp"})
     public void testSuggestionLoadingInitiallyEmpty() {
+        final int category = KnownCategories.ARTICLES;
+
         // If we don't get anything, we should be in the same situation as the initial one.
-        mSource.setSuggestionsForCategory(
-                KnownCategories.ARTICLES, new ArrayList<SnippetArticle>());
+        mSource.setSuggestionsForCategory(category, new ArrayList<SnippetArticle>());
         assertItemsFor(sectionWithStatusCard().withProgress());
 
         // We should load new suggestions when we get notified about them.
         final int numSuggestions = 5;
-        List<SnippetArticle> suggestions = createDummySuggestions(numSuggestions);
-        mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.AVAILABLE);
-        mSource.setSuggestionsForCategory(KnownCategories.ARTICLES, suggestions);
+
+        List<SnippetArticle> suggestions = createDummySuggestions(numSuggestions, category);
+        mSource.setStatusForCategory(category, CategoryStatus.AVAILABLE);
+        mSource.setSuggestionsForCategory(category, suggestions);
 
         assertItemsFor(section(numSuggestions));
     }
 
     /**
      * Tests that the adapter clears the suggestions when asked to.
      */
     @Test
     @Feature({"Ntp"})
     public void testSuggestionClearing() {
-        List<SnippetArticle> suggestions = createDummySuggestions(4);
+        List<SnippetArticle> suggestions = createDummySuggestions(4, KnownCategories.ARTICLES);
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.AVAILABLE);
         mSource.setSuggestionsForCategory(KnownCategories.ARTICLES, suggestions);
         assertItemsFor(section(4));
 
         // If we get told that the category is enabled, we just leave the current suggestions do not
         // clear them.
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.AVAILABLE);
         assertItemsFor(section(4));
 
         // When the category is disabled, the suggestions are cleared and we should go back to
         // the situation with the status card.
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.SIGNED_OUT);
         assertItemsFor(sectionWithStatusCard());
 
         // The adapter should now be waiting for new suggestions.
-        suggestions = createDummySuggestions(6);
+        suggestions = createDummySuggestions(6, KnownCategories.ARTICLES);
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.AVAILABLE);
         mSource.setSuggestionsForCategory(KnownCategories.ARTICLES, suggestions);
         assertItemsFor(section(6));
     }
 
     /**
      * Tests that the adapter loads suggestions only when the status is favorable.
      */
     @Test
     @Feature({"Ntp"})
     public void testSuggestionLoadingBlock() {
-        List<SnippetArticle> suggestions = createDummySuggestions(3);
+        List<SnippetArticle> suggestions = createDummySuggestions(3, KnownCategories.ARTICLES);
 
         // By default, status is INITIALIZING, so we can load suggestions.
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.AVAILABLE);
         mSource.setSuggestionsForCategory(KnownCategories.ARTICLES, suggestions);
         assertItemsFor(section(3));
 
         // Add another snippet.
-        suggestions.add(new SnippetArticle(0, "https://site.com/url1", "title1", "pub1", "txt1",
-                "https://site.com/url1", 0, 0, 0));
+        suggestions.add(new SnippetArticle(KnownCategories.ARTICLES, "https://site.com/url1",
+                "title1", "pub1", "txt1", "https://site.com/url1", 0, 0));
 
         // When snippets are disabled, we should not be able to load them.
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.SIGNED_OUT);
         mSource.setSuggestionsForCategory(KnownCategories.ARTICLES, suggestions);
         assertItemsFor(sectionWithStatusCard());
 
         // INITIALIZING lets us load snippets still.
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.INITIALIZING);
         mSource.setSuggestionsForCategory(KnownCategories.ARTICLES, suggestions);
         assertItemsFor(sectionWithStatusCard().withProgress());
@@ skipping 27 matching lines @@
         assertFalse(progress.isVisible());
     }
 
     /**
      * Tests that the entire section disappears if its status switches to LOADING_ERROR or
      * CATEGORY_EXPLICITLY_DISABLED. Also tests that they are not shown when the NTP reloads.
      */
     @Test
     @Feature({"Ntp"})
     public void testSectionClearingWhenUnavailable() {
-        List<SnippetArticle> snippets = createDummySuggestions(5);
+        List<SnippetArticle> snippets = createDummySuggestions(5, KnownCategories.ARTICLES);
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.AVAILABLE);
         mSource.setSuggestionsForCategory(KnownCategories.ARTICLES, snippets);
         assertItemsFor(section(5));
 
         // When the category goes away with a hard error, the section is cleared from the UI.
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.LOADING_ERROR);
         assertItemsFor();
 
         // Same when loading a new NTP.
         reloadNtp();
@@ skipping 11 matching lines @@
         reloadNtp();
         assertItemsFor();
     }
 
     /**
      * Tests that the UI remains untouched if a category switches to NOT_PROVIDED.
      */
     @Test
     @Feature({"Ntp"})
     public void testUIUntouchedWhenNotProvided() {
-        List<SnippetArticle> snippets = createDummySuggestions(4);
+        List<SnippetArticle> snippets = createDummySuggestions(4, KnownCategories.ARTICLES);
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.AVAILABLE);
         mSource.setSuggestionsForCategory(KnownCategories.ARTICLES, snippets);
         assertItemsFor(section(4));
 
         // When the category switches to NOT_PROVIDED, UI stays the same.
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.NOT_PROVIDED);
         mSource.silentlyRemoveCategory(KnownCategories.ARTICLES);
         assertItemsFor(section(4));
 
         reloadNtp();
         assertItemsFor();
     }
 
     /**
      * Tests that the UI updates on updated suggestions.
      */
     @Test
     @Feature({"Ntp"})
     public void testUIUpdatesOnNewSuggestionsWhenOtherSectionSeen() {
-        List<SnippetArticle> snippets = createDummySuggestions(4);
+        List<SnippetArticle> snippets = createDummySuggestions(4, KnownCategories.ARTICLES);
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.AVAILABLE);
         mSource.setSuggestionsForCategory(KnownCategories.ARTICLES, snippets);
 
-        List<SnippetArticle> bookmarks = createDummySuggestions(2);
+        List<SnippetArticle> bookmarks = createDummySuggestions(2, KnownCategories.BOOKMARKS);
         mSource.setStatusForCategory(KnownCategories.BOOKMARKS, CategoryStatus.AVAILABLE);
         mSource.setInfoForCategory(KnownCategories.BOOKMARKS,
                 new CategoryInfoBuilder(KnownCategories.BOOKMARKS).showIfEmpty().build());
         mSource.setSuggestionsForCategory(KnownCategories.BOOKMARKS, bookmarks);
 
         reloadNtp();
         assertItemsFor(section(4), section(2));
 
         mAdapter.getSectionListForTesting()
                 .getSectionForTesting(KnownCategories.BOOKMARKS)
                 .childSeen(2);
 
-        List<SnippetArticle> newSnippets = createDummySuggestions(3);
+        List<SnippetArticle> newSnippets = createDummySuggestions(3, KnownCategories.ARTICLES);
         mSource.setSuggestionsForCategory(KnownCategories.ARTICLES, newSnippets);
         assertItemsFor(section(3), section(2));
 
         reloadNtp();
         assertItemsFor(section(3), section(2));
     }
 
     /**
     * Tests that the UI updates the first item of the section if the first item of some other
     * section has been viewed.
     */
     @Test
     @Feature({"Ntp"})
     public void testUIUpdatesOnNewSuggestionsWhenFirstOfOtherSectionIsSeen() {
-        List<SnippetArticle> snippets = createDummySuggestions(4);
-        SnippetArticle earlier = snippets.get(0);
+        List<SnippetArticle> snippets = createDummySuggestions(4, KnownCategories.ARTICLES);
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.AVAILABLE);
         mSource.setSuggestionsForCategory(KnownCategories.ARTICLES, snippets);
 
-        List<SnippetArticle> bookmarks = createDummySuggestions(1);
+        List<SnippetArticle> bookmarks = createDummySuggestions(1, KnownCategories.BOOKMARKS);
         mSource.setStatusForCategory(KnownCategories.BOOKMARKS, CategoryStatus.AVAILABLE);
         mSource.setInfoForCategory(KnownCategories.BOOKMARKS,
                 new CategoryInfoBuilder(KnownCategories.BOOKMARKS).showIfEmpty().build());
         mSource.setSuggestionsForCategory(KnownCategories.BOOKMARKS, bookmarks);
 
         reloadNtp();
         assertItemsFor(section(4), section(1));
 
         mAdapter.getSectionListForTesting()
                 .getSectionForTesting(KnownCategories.BOOKMARKS)
                 .childSeen(1);
 
-        List<SnippetArticle> newSnippets = createDummySuggestions(3);
+        List<SnippetArticle> newSnippets = createDummySuggestions(3, KnownCategories.ARTICLES);
         SnippetArticle newer = newSnippets.get(0);
 
         mSource.setSuggestionsForCategory(KnownCategories.ARTICLES, newSnippets);
         assertItemsFor(section(3).withFirstItem(newer), section(1));
 
         reloadNtp();
         assertItemsFor(section(3).withFirstItem(newer), section(1));
     }
 
     /** Tests whether a section stays visible if empty, if required. */
     @Test
     @Feature({"Ntp"})
     public void testSectionVisibleIfEmpty() {
         @CategoryInt
         final int category = 42;
 
         // Part 1: VisibleIfEmpty = true
         FakeSuggestionsSource suggestionsSource = new FakeSuggestionsSource();
         suggestionsSource.setStatusForCategory(category, CategoryStatus.INITIALIZING);
         suggestionsSource.setInfoForCategory(category,
                 new CategoryInfoBuilder(category).showIfEmpty().build());
 
         // 1.1 - Initial state
         when(mNewTabPageManager.getSuggestionsSource()).thenReturn(suggestionsSource);
         reloadNtp();
         assertItemsFor(sectionWithStatusCard().withProgress());
 
         // 1.2 - With suggestions
-        List<SnippetArticle> articles = Collections.unmodifiableList(createDummySuggestions(3));
+        List<SnippetArticle> articles =
+                Collections.unmodifiableList(createDummySuggestions(3, category));
         suggestionsSource.setStatusForCategory(category, CategoryStatus.AVAILABLE);
         suggestionsSource.setSuggestionsForCategory(category, articles);
         assertItemsFor(section(3));
 
         // 1.3 - When all suggestions are dismissed
         SuggestionsSection section42 =
                 mAdapter.getSectionListForTesting().getSectionForTesting(category);
         assertSectionMatches(section(3), section42);
         section42.removeSuggestionById(articles.get(0).mIdWithinCategory);
         section42.removeSuggestionById(articles.get(1).mIdWithinCategory);
@@ skipping 34 matching lines @@
                                                                .withViewAllAction()
                                                                .showIfEmpty()
                                                                .build());
 
         // 1.1 - Initial state.
         when(mNewTabPageManager.getSuggestionsSource()).thenReturn(suggestionsSource);
         reloadNtp();
         assertItemsFor(sectionWithStatusCard().withActionButton().withProgress());
 
         // 1.2 - With suggestions.
-        List<SnippetArticle> articles = Collections.unmodifiableList(createDummySuggestions(3));
+        List<SnippetArticle> articles =
+                Collections.unmodifiableList(createDummySuggestions(3, category));
         suggestionsSource.setStatusForCategory(category, CategoryStatus.AVAILABLE);
         suggestionsSource.setSuggestionsForCategory(category, articles);
         assertItemsFor(section(3).withActionButton());
 
         // 1.3 - When all suggestions are dismissed.
         SuggestionsSection section42 =
                 mAdapter.getSectionListForTesting().getSectionForTesting(category);
         assertSectionMatches(section(3).withActionButton(), section42);
         section42.removeSuggestionById(articles.get(0).mIdWithinCategory);
         section42.removeSuggestionById(articles.get(1).mIdWithinCategory);
@@ skipping 24 matching lines @@
         section42.removeSuggestionById(articles.get(2).mIdWithinCategory);
         assertItemsFor(sectionWithStatusCard());
     }
 
     /**
      * Tests that invalidated suggestions are immediately removed.
      */
     @Test
     @Feature({"Ntp"})
     public void testSuggestionInvalidated() {
-        List<SnippetArticle> articles = createDummySuggestions(3);
+        List<SnippetArticle> articles = createDummySuggestions(3, KnownCategories.ARTICLES);
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.AVAILABLE);
         mSource.setSuggestionsForCategory(KnownCategories.ARTICLES, articles);
         assertItemsFor(section(3));
         assertArticlesEqual(articles, 2, 5);
 
         SnippetArticle removed = articles.remove(1);
         mSource.fireSuggestionInvalidated(KnownCategories.ARTICLES, removed.mIdWithinCategory);
         assertArticlesEqual(articles, 2, 4);
     }
 
     /**
      * Tests that the UI handles dynamically added (server-side) categories correctly.
      */
     @Test
     @Feature({"Ntp"})
     public void testDynamicCategories() {
-        List<SnippetArticle> articles = createDummySuggestions(3);
+        List<SnippetArticle> articles = createDummySuggestions(3, KnownCategories.ARTICLES);
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.AVAILABLE);
         mSource.setSuggestionsForCategory(KnownCategories.ARTICLES, articles);
         assertItemsFor(section(3));
 
         int dynamicCategory1 = 1010;
-        List<SnippetArticle> dynamics1 = createDummySuggestions(5);
+        List<SnippetArticle> dynamics1 = createDummySuggestions(5, KnownCategories.ARTICLES);
         mSource.setInfoForCategory(dynamicCategory1, new CategoryInfoBuilder(dynamicCategory1)
                                                              .withViewAllAction()
                                                              .build());
         mSource.setStatusForCategory(dynamicCategory1, CategoryStatus.AVAILABLE);
         mSource.setSuggestionsForCategory(dynamicCategory1, dynamics1);
         reloadNtp();
 
         assertItemsFor(section(3), section(5).withActionButton());
 
         int dynamicCategory2 = 1011;
-        List<SnippetArticle> dynamics2 = createDummySuggestions(11);
+        List<SnippetArticle> dynamics2 = createDummySuggestions(11, KnownCategories.ARTICLES);
         mSource.setInfoForCategory(dynamicCategory2,
                 new CategoryInfoBuilder(dynamicCategory1).build());
         mSource.setStatusForCategory(dynamicCategory2, CategoryStatus.AVAILABLE);
         mSource.setSuggestionsForCategory(dynamicCategory2, dynamics2);
         reloadNtp();
         assertItemsFor(section(3), section(5).withActionButton(), section(11));
     }
 
     /**
      * Tests that the order of the categories is kept.
@@ skipping 116 matching lines @@
         // 0   | Above-the-fold
         // 1   | Header
         // 2   | Status
         // 3   | Action
         // 4   | Progress Indicator
         // 5   | Footer
         // 6   | Spacer
 
         final int newSuggestionCount = 7;
         reset(dataObserver);
-        suggestionsSource.setSuggestionsForCategory(
-                KnownCategories.ARTICLES, createDummySuggestions(newSuggestionCount));
+        suggestionsSource.setSuggestionsForCategory(KnownCategories.ARTICLES,
+                createDummySuggestions(newSuggestionCount, KnownCategories.ARTICLES));
         verify(dataObserver).onItemRangeInserted(2, newSuggestionCount);
         verify(dataObserver).onItemRangeChanged(5 + newSuggestionCount, 1, null); // Spacer refresh
         verify(dataObserver, times(2)).onItemRangeRemoved(2 + newSuggestionCount, 1);
         verify(dataObserver).onItemRangeChanged(4 + newSuggestionCount, 1, null); // Spacer refresh
         verify(dataObserver).onItemRangeChanged(3 + newSuggestionCount, 1, null); // Spacer refresh
 
         // Adapter content:
         // Idx | Item
         // ----|----------------
         // 0   | Above-the-fold
         // 1   | Header
         // 2-8 | Sugg*7
         // 9   | Footer
         // 10  | Spacer
 
         verifyNoMoreInteractions(dataObserver);
         reset(dataObserver);
         suggestionsSource.setSuggestionsForCategory(
-                KnownCategories.ARTICLES, createDummySuggestions(0));
+                KnownCategories.ARTICLES, createDummySuggestions(0, KnownCategories.ARTICLES));
         mAdapter.getSectionListForTesting().onCategoryStatusChanged(
                 KnownCategories.ARTICLES, CategoryStatus.SIGNED_OUT);
         verify(dataObserver).onItemRangeRemoved(2, newSuggestionCount);
         verify(dataObserver).onItemRangeChanged(3, 1, null); // Spacer refresh
         verify(dataObserver).onItemRangeInserted(2, 1); // Status card added
         verify(dataObserver).onItemRangeChanged(4, 1, null); // Spacer refresh
         verify(dataObserver).onItemRangeInserted(3, 1); // Action item added
         verify(dataObserver).onItemRangeChanged(5, 1, null); // Spacer refresh
         verifyNoMoreInteractions(dataObserver);
     }
@@ skipping 153 matching lines @@
         // 1   | Sign In Promo
         // 2   | Footer
         // 3   | Spacer
         assertEquals(ItemViewType.FOOTER, mAdapter.getItemViewType(2));
         assertEquals(RecyclerView.NO_POSITION,
                 mAdapter.getFirstPositionForType(ItemViewType.ALL_DISMISSED));
 
         // Prepare some suggestions. They should not load because the category is dismissed on
         // the current NTP.
         mSource.setStatusForCategory(KnownCategories.ARTICLES, CategoryStatus.AVAILABLE);
-        mSource.setSuggestionsForCategory(KnownCategories.ARTICLES, createDummySuggestions(1));
+        mSource.setSuggestionsForCategory(
+                KnownCategories.ARTICLES, createDummySuggestions(1, KnownCategories.ARTICLES));
         mSource.setInfoForCategory(KnownCategories.ARTICLES,
                 new CategoryInfoBuilder(KnownCategories.ARTICLES).build());
         assertEquals(4, mAdapter.getItemCount()); // TODO(dgn): rewrite with section descriptors.
 
         // On Sign in, we should reset the sections, bring back suggestions instead of the All
         // Dismissed item.
         mAdapter.getSectionListForTesting().onFullRefreshRequired();
         when(mMockSigninManager.isSignInAllowed()).thenReturn(true);
         signinObserver.onSignedIn();
         // Adapter content:
@@ skipping 116 matching lines @@
                     viewTypeToString(expectedType));
         }
         addLine(stringBuilder, "explainFailedExpectation -- END --");
         return stringBuilder.toString();
     }
 
     private static void addLine(StringBuilder stringBuilder, String template, Object... args) {
         stringBuilder.append(String.format(Locale.US, template + "\n", args));
     }
 }