Use improved VariationParamsManager to hide details.

components/ntp_snippets/remote/ntp_snippets_fetcher_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/ntp_snippets_fetcher.h"
 
 #include <deque>
 #include <map>
 #include <utility>
 
@@ skipping 258 matching lines @@
     const ntp_snippets::NTPSnippetsFetcher::SuccessCallback& success_callback,
     const ntp_snippets::NTPSnippetsFetcher::ErrorCallback& error_callback) {
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&ParseJson, json, std::move(success_callback),
                             std::move(error_callback)),
       base::TimeDelta::FromMilliseconds(kTestJsonParsingLatencyMs));
 }
 
 }  // namespace
 
-class NTPSnippetsFetcherTest : public testing::Test {
+class NTPSnippetsFetcherTestBase : public testing::Test {
  public:
-  // TODO(fhorschig): As soon as crbug.com/645447 is resolved, use
-  // variations::testing::VariationParamsManager to configure these values.
-  class RequestBuilderWithMockedFlagsForTesting
-      : public NTPSnippetsFetcher::RequestBuilder {
-   public:
-    RequestBuilderWithMockedFlagsForTesting() : RequestBuilder() {}
-
-   private:
-    bool IsSendingUserClassEnabled() const override { return true; }
-    bool IsSendingTopLanguagesEnabled() const override { return true; }
-  };
-
-  NTPSnippetsFetcherTest()
-      : NTPSnippetsFetcherTest(GURL(kTestChromeReaderUrl),
-                               std::map<std::string, std::string>()) {}
-
-  NTPSnippetsFetcherTest(const GURL& gurl,
-                         const std::map<std::string, std::string>& params)
-      : params_manager_(
+  explicit NTPSnippetsFetcherTestBase(const GURL& gurl)
+      : default_variation_params_(
+            {{"send_top_languages", "true"}, {"send_user_class", "true"}}),
+        params_manager_(
             base::MakeUnique<variations::testing::VariationParamsManager>(
                 ntp_snippets::kStudyName,
-                params)),
+                default_variation_params_,
+                std::set<std::string>{
+                    ntp_snippets::kArticleSuggestionsFeature.name})),
         mock_task_runner_(new base::TestMockTimeTaskRunner()),
         mock_task_runner_handle_(mock_task_runner_),
         signin_client_(base::MakeUnique<TestSigninClient>(nullptr)),
         account_tracker_(base::MakeUnique<AccountTrackerService>()),
         fake_signin_manager_(
             base::MakeUnique<FakeSigninManagerBase>(signin_client_.get(),
                                                     account_tracker_.get())),
         fake_token_service_(base::MakeUnique<FakeProfileOAuth2TokenService>()),
         pref_service_(base::MakeUnique<TestingPrefServiceSimple>()),
         test_url_(gurl) {
@@ skipping 41 matching lines @@
   void InitFakeURLFetcherFactory() {
     if (fake_url_fetcher_factory_) {
       return;
     }
     // Instantiation of factory automatically sets itself as URLFetcher's
     // factory.
     fake_url_fetcher_factory_.reset(new net::FakeURLFetcherFactory(
         /*default_factory=*/&failing_url_fetcher_factory_));
   }
 
-  void SetFetchingPersonalizationVariation(
-      const std::string& personalization_string) {
+  void SetDefaultVariationParam(std::string param_name, std::string value) {
+    default_variation_params_[param_name] = value;
+    SetVariationParam(param_name, value);
+  }
+
+  void SetVariationParam(std::string param_name, std::string value) {
     params_manager_.reset();
-    std::map<std::string, std::string> params = {
-        {"fetching_personalization", personalization_string}};
+
+    std::map<std::string, std::string> params = default_variation_params_;
+    params[param_name] = value;
+
     params_manager_ =
         base::MakeUnique<variations::testing::VariationParamsManager>(
-            ntp_snippets::kStudyName, params);
+            ntp_snippets::kStudyName, params,
+            std::set<std::string>{
+                ntp_snippets::kArticleSuggestionsFeature.name});
   }
 
   void SetVariationParametersForFeatures(
       const std::map<std::string, std::string>& params,
       const std::set<std::string>& features) {
     params_manager_.reset();
     params_manager_ =
         base::MakeUnique<variations::testing::VariationParamsManager>(
             ntp_snippets::kStudyName, params, features);
   }
@@ skipping 15 matching lines @@
       for (const auto& code : codes) {
         language_model->OnPageVisited(code);
       }
     }
     return language_model;
   }
 
   TestingPrefServiceSimple* pref_service() const { return pref_service_.get(); }
 
  private:
-  // TODO(fhorschig): Make it a simple member as soon as it resets properly.
+  std::map<std::string, std::string> default_variation_params_;
+  // TODO(fhorschig): Make it a simple member when crbug.com/672010 is resolved.
   std::unique_ptr<variations::testing::VariationParamsManager> params_manager_;
   scoped_refptr<base::TestMockTimeTaskRunner> mock_task_runner_;
   base::ThreadTaskRunnerHandle mock_task_runner_handle_;
   FailingFakeURLFetcherFactory failing_url_fetcher_factory_;
   // Initialized lazily in SetFakeResponse().
   std::unique_ptr<net::FakeURLFetcherFactory> fake_url_fetcher_factory_;
   std::unique_ptr<TestSigninClient> signin_client_;
   std::unique_ptr<AccountTrackerService> account_tracker_;
   std::unique_ptr<SigninManagerBase> fake_signin_manager_;
   std::unique_ptr<OAuth2TokenService> fake_token_service_;
   std::unique_ptr<NTPSnippetsFetcher> snippets_fetcher_;
   std::unique_ptr<TestingPrefServiceSimple> pref_service_;
   std::unique_ptr<UserClassifier> user_classifier_;
   CategoryFactory category_factory_;
   MockSnippetsAvailableCallback mock_callback_;
   const GURL test_url_;
   base::HistogramTester histogram_tester_;
 
-  DISALLOW_COPY_AND_ASSIGN(NTPSnippetsFetcherTest);
+  DISALLOW_COPY_AND_ASSIGN(NTPSnippetsFetcherTestBase);
 };
 
-class NTPSnippetsContentSuggestionsFetcherTest : public NTPSnippetsFetcherTest {
+class ChromeReaderSnippetsFetcherTest : public NTPSnippetsFetcherTestBase {
+ public:
+  ChromeReaderSnippetsFetcherTest()
+      : NTPSnippetsFetcherTestBase(GURL(kTestChromeReaderUrl)) {}
+};
+
+class NTPSnippetsContentSuggestionsFetcherTest
+    : public NTPSnippetsFetcherTestBase {
  public:
   NTPSnippetsContentSuggestionsFetcherTest()
-      : NTPSnippetsFetcherTest(
-            GURL(kTestChromeContentSuggestionsUrl),
-            {{"content_suggestions_backend", kContentSuggestionsServer}}) {}
+      : NTPSnippetsFetcherTestBase(GURL(kTestChromeContentSuggestionsUrl)) {
+    SetDefaultVariationParam("content_suggestions_backend",
+                             kContentSuggestionsServer);
+    ResetSnippetsFetcher();
+  }
 };
 
-TEST_F(NTPSnippetsFetcherTest, BuildRequestAuthenticated) {
+TEST_F(ChromeReaderSnippetsFetcherTest, BuildRequestAuthenticated) {
   NTPSnippetsFetcher::RequestBuilder builder;
   NTPSnippetsFetcher::Params params;
   params.hosts = {"chromium.org"};
   params.excluded_ids = {"1234567890"};
   params.count_to_fetch = 25;
   params.interactive_request = false;
   builder.SetParams(params)
       .SetAuthentication("0BFUSGAIA", "headerstuff")
       .SetPersonalization(NTPSnippetsFetcher::Personalization::kPersonal)
       .SetUserClassForTesting("ACTIVE_NTP_USER")
@@ skipping 48 matching lines @@
                          "  \"regularlyVisitedHostNames\": ["
                          "    \"chromium.org\""
                          "  ],"
                          "  \"excludedSuggestionIds\": ["
                          "    \"1234567890\""
                          "  ],"
                          "  \"userActivenessClass\": \"ACTIVE_NTP_USER\""
                          "}"));
 }
 
-TEST_F(NTPSnippetsFetcherTest, BuildRequestUnauthenticated) {
+TEST_F(ChromeReaderSnippetsFetcherTest, BuildRequestUnauthenticated) {
   NTPSnippetsFetcher::RequestBuilder builder;
   NTPSnippetsFetcher::Params params = test_params();
   params.count_to_fetch = 10;
   builder.SetParams(params)
       .SetUserClassForTesting("ACTIVE_NTP_USER")
       .SetPersonalization(NTPSnippetsFetcher::Personalization::kNonPersonal)
       .SetFetchAPI(NTPSnippetsFetcher::CHROME_READER_API);
 
   EXPECT_THAT(builder.PreviewRequestHeadersForTesting(),
               StrEq("Content-Type: application/json; charset=UTF-8\r\n"
@@ skipping 33 matching lines @@
       NTPSnippetsFetcher::FetchAPI::CHROME_CONTENT_SUGGESTIONS_API);
   EXPECT_THAT(builder.PreviewRequestBodyForTesting(),
               EqualsJSON("{"
                          "  \"regularlyVisitedHostNames\": [],"
                          "  \"priority\": \"USER_ACTION\","
                          "  \"excludedSuggestionIds\": [],"
                          "  \"userActivenessClass\": \"ACTIVE_NTP_USER\""
                          "}"));
 }
 
-TEST_F(NTPSnippetsFetcherTest, BuildRequestExcludedIds) {
+TEST_F(ChromeReaderSnippetsFetcherTest, BuildRequestExcludedIds) {
   NTPSnippetsFetcher::RequestBuilder builder;
   NTPSnippetsFetcher::Params params = test_params();
   params.interactive_request = false;
   for (int i = 0; i < 200; ++i) {
     params.excluded_ids.insert(base::StringPrintf("%03d", i));
   }
   builder.SetParams(params)
       .SetUserClassForTesting("ACTIVE_NTP_USER")
       .SetPersonalization(NTPSnippetsFetcher::Personalization::kNonPersonal)
       .SetFetchAPI(
@@ skipping 24 matching lines @@
                          "    \"085\", \"086\", \"087\", \"088\", \"089\","
                          "    \"090\", \"091\", \"092\", \"093\", \"094\","
                          "    \"095\", \"096\", \"097\", \"098\", \"099\""
                          // Truncated to 100 entries. Currently, they happen to
                          // be those lexically first.
                          "  ],"
                          "  \"userActivenessClass\": \"ACTIVE_NTP_USER\""
                          "}"));
 }
 
-TEST_F(NTPSnippetsFetcherTest, BuildRequestNoUserClass) {
+TEST_F(ChromeReaderSnippetsFetcherTest, BuildRequestNoUserClass) {
   NTPSnippetsFetcher::RequestBuilder builder;
   NTPSnippetsFetcher::Params params = test_params();
   params.interactive_request = false;
   builder.SetPersonalization(NTPSnippetsFetcher::Personalization::kNonPersonal)
       .SetParams(params)
       .SetFetchAPI(
           NTPSnippetsFetcher::FetchAPI::CHROME_CONTENT_SUGGESTIONS_API);
 
   EXPECT_THAT(builder.PreviewRequestBodyForTesting(),
               EqualsJSON("{"
                          "  \"regularlyVisitedHostNames\": [],"
                          "  \"priority\": \"BACKGROUND_PREFETCH\","
                          "  \"excludedSuggestionIds\": []"
                          "}"));
 }
 
-TEST_F(NTPSnippetsFetcherTest, BuildRequestWithTwoLanguages) {
-  RequestBuilderWithMockedFlagsForTesting builder;
+TEST_F(ChromeReaderSnippetsFetcherTest, BuildRequestWithTwoLanguages) {
+  NTPSnippetsFetcher::RequestBuilder builder;
   std::unique_ptr<translate::LanguageModel> language_model =
       MakeLanguageModel({"de", "en"});
   NTPSnippetsFetcher::Params params = test_params();
   params.language_code = "en";
   builder.SetParams(params)
       .SetLanguageModel(language_model.get())
       .SetPersonalization(NTPSnippetsFetcher::Personalization::kNonPersonal)
       .SetFetchAPI(
           NTPSnippetsFetcher::FetchAPI::CHROME_CONTENT_SUGGESTIONS_API);
 
   EXPECT_THAT(builder.PreviewRequestBodyForTesting(),
               EqualsJSON("{"
                          "  \"regularlyVisitedHostNames\": [],"
                          "  \"priority\": \"USER_ACTION\","
                          "  \"uiLanguage\": \"en\","
                          "  \"excludedSuggestionIds\": [],"
                          "  \"topLanguages\": ["
                          "    {"
                          "      \"language\" : \"en\","
                          "      \"frequency\" : 0.5"
                          "    },"
                          "    {"
                          "      \"language\" : \"de\","
                          "      \"frequency\" : 0.5"
                          "    }"
                          "  ]"
                          "}"));
 }
 
-TEST_F(NTPSnippetsFetcherTest, BuildRequestWithUILanguageOnly) {
-  RequestBuilderWithMockedFlagsForTesting builder;
+TEST_F(ChromeReaderSnippetsFetcherTest, BuildRequestWithUILanguageOnly) {
+  NTPSnippetsFetcher::RequestBuilder builder;
   std::unique_ptr<translate::LanguageModel> language_model =
       MakeLanguageModel({"en"});
   NTPSnippetsFetcher::Params params = test_params();
   params.language_code = "en";
   builder.SetParams(params)
       .SetLanguageModel(language_model.get())
       .SetPersonalization(NTPSnippetsFetcher::Personalization::kNonPersonal)
       .SetFetchAPI(
           NTPSnippetsFetcher::FetchAPI::CHROME_CONTENT_SUGGESTIONS_API);
 
   EXPECT_THAT(builder.PreviewRequestBodyForTesting(),
               EqualsJSON("{"
                          "  \"regularlyVisitedHostNames\": [],"
                          "  \"priority\": \"USER_ACTION\","
                          "  \"uiLanguage\": \"en\","
                          "  \"excludedSuggestionIds\": [],"
                          "  \"topLanguages\": [{"
                          "    \"language\" : \"en\","
                          "    \"frequency\" : 1.0"
                          "  }]"
                          "}"));
 }
 
-TEST_F(NTPSnippetsFetcherTest, ShouldNotFetchOnCreation) {
+TEST_F(ChromeReaderSnippetsFetcherTest, ShouldNotFetchOnCreation) {
   // The lack of registered baked in responses would cause any fetch to fail.
   FastForwardUntilNoTasksRemain();
   EXPECT_THAT(histogram_tester().GetAllSamples(
                   "NewTabPage.Snippets.FetchHttpResponseOrErrorCode"),
               IsEmpty());
   EXPECT_THAT(histogram_tester().GetAllSamples("NewTabPage.Snippets.FetchTime"),
               IsEmpty());
   EXPECT_THAT(snippets_fetcher().last_status(), IsEmpty());
 }
 
-TEST_F(NTPSnippetsFetcherTest, ShouldFetchSuccessfully) {
+TEST_F(ChromeReaderSnippetsFetcherTest, ShouldFetchSuccessfully) {
   const std::string kJsonStr =
       "{\"recos\": [{"
       "  \"contentInfo\": {"
       "    \"url\" : \"http://localhost/foobar\","
       "    \"sourceCorpusInfo\" : [{"
       "      \"ampUrl\" : \"http://localhost/amp\","
       "      \"corpusId\" : \"http://localhost/foobar\","
       "      \"publisherData\": { \"sourceName\" : \"Foo News\" }"
       "    }]"
       "  }"
@@ skipping 252 matching lines @@
 
   ASSERT_TRUE(fetched_categories);
   ASSERT_THAT(fetched_categories->size(), Eq(1u));
   const auto& category = (*fetched_categories)[0];
   EXPECT_THAT(category.category.id(),
               Eq(CategoryFactory().FromRemoteCategory(2).id()));
   ASSERT_THAT(category.snippets.size(), Eq(1u));
   EXPECT_THAT(category.snippets[0]->url().spec(), Eq("http://localhost/foo2"));
 }
 
-TEST_F(NTPSnippetsFetcherTest, PersonalizesDependingOnVariations) {
+TEST_F(ChromeReaderSnippetsFetcherTest, PersonalizesDependingOnVariations) {
   // Default setting should be both personalization options.
   EXPECT_THAT(snippets_fetcher().personalization(),
               Eq(NTPSnippetsFetcher::Personalization::kBoth));
 
-  SetFetchingPersonalizationVariation("personal");
+  SetVariationParam("fetching_personalization", "personal");
   ResetSnippetsFetcher();
   EXPECT_THAT(snippets_fetcher().personalization(),
               Eq(NTPSnippetsFetcher::Personalization::kPersonal));
 
-  SetFetchingPersonalizationVariation("non_personal");
+  SetVariationParam("fetching_personalization", "non_personal");
   ResetSnippetsFetcher();
   EXPECT_THAT(snippets_fetcher().personalization(),
               Eq(NTPSnippetsFetcher::Personalization::kNonPersonal));
 
-  SetFetchingPersonalizationVariation("both");
+  SetVariationParam("fetching_personalization", "both");
   ResetSnippetsFetcher();
   EXPECT_THAT(snippets_fetcher().personalization(),
               Eq(NTPSnippetsFetcher::Personalization::kBoth));
 }
 
-TEST_F(NTPSnippetsFetcherTest, ShouldFetchSuccessfullyEmptyList) {
+TEST_F(ChromeReaderSnippetsFetcherTest, ShouldFetchSuccessfullyEmptyList) {
   const std::string kJsonStr = "{\"recos\": []}";
   SetFakeResponse(/*response_data=*/kJsonStr, net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(mock_callback(), Run(NTPSnippetsFetcher::FetchResult::SUCCESS,
                                    IsEmptyArticleList()));
   snippets_fetcher().FetchSnippets(
       test_params(), ToSnippetsAvailableCallback(&mock_callback()));
   FastForwardUntilNoTasksRemain();
   EXPECT_THAT(snippets_fetcher().last_status(), Eq("OK"));
   EXPECT_THAT(snippets_fetcher().last_json(), Eq(kJsonStr));
   EXPECT_THAT(
       histogram_tester().GetAllSamples("NewTabPage.Snippets.FetchResult"),
       ElementsAre(base::Bucket(/*min=*/0, /*count=*/1)));
   EXPECT_THAT(histogram_tester().GetAllSamples(
                   "NewTabPage.Snippets.FetchHttpResponseOrErrorCode"),
               ElementsAre(base::Bucket(/*min=*/200, /*count=*/1)));
 }
 
-TEST_F(NTPSnippetsFetcherTest, ShouldRestrictToHosts) {
+TEST_F(ChromeReaderSnippetsFetcherTest, ShouldRestrictToHosts) {
   DelegateCallingTestURLFetcherFactory fetcher_factory;
   NTPSnippetsFetcher::Params params = test_params();
   params.hosts = {"www.somehost1.com", "www.somehost2.com"};
   params.count_to_fetch = 17;
 
   snippets_fetcher().FetchSnippets(
       params, ToSnippetsAvailableCallback(&mock_callback()));
 
   net::TestURLFetcher* fetcher = fetcher_factory.GetLastCreatedFetcher();
   ASSERT_THAT(fetcher, NotNull());
@@ skipping 13 matching lines @@
   const base::DictionaryValue* content_selector = nullptr;
   ASSERT_TRUE(content_selectors->GetDictionary(0, &content_selector));
   std::string content_selector_value;
   EXPECT_TRUE(content_selector->GetString("value", &content_selector_value));
   EXPECT_THAT(content_selector_value, Eq("www.somehost1.com"));
   ASSERT_TRUE(content_selectors->GetDictionary(1, &content_selector));
   EXPECT_TRUE(content_selector->GetString("value", &content_selector_value));
   EXPECT_THAT(content_selector_value, Eq("www.somehost2.com"));
 }
 
-TEST_F(NTPSnippetsFetcherTest, RetryOnInteractiveRequests) {
+TEST_F(ChromeReaderSnippetsFetcherTest, RetryOnInteractiveRequests) {
   DelegateCallingTestURLFetcherFactory fetcher_factory;
   NTPSnippetsFetcher::Params params = test_params();
   params.interactive_request = true;
 
   snippets_fetcher().FetchSnippets(
       params, ToSnippetsAvailableCallback(&mock_callback()));
 
   net::TestURLFetcher* fetcher = fetcher_factory.GetLastCreatedFetcher();
   ASSERT_THAT(fetcher, NotNull());
   EXPECT_THAT(fetcher->GetMaxRetriesOn5xx(), Eq(2));
 }
 
-TEST_F(NTPSnippetsFetcherTest, RetriesConfigurableOnNonInteractiveRequests) {
+TEST_F(ChromeReaderSnippetsFetcherTest,
+       RetriesConfigurableOnNonInteractiveRequests) {
   struct ExpectationForVariationParam {
     std::string param_value;
     int expected_value;
     std::string description;
   };
   const std::vector<ExpectationForVariationParam> retry_config_expectation = {
       {"", 0, "Do not retry by default"},
       {"0", 0, "Do not retry on param value 0"},
       {"-1", 0, "Do not retry on negative param values."},
       {"4", 4, "Retry as set in param value."}};
@@ skipping 10 matching lines @@
     snippets_fetcher().FetchSnippets(
         params, ToSnippetsAvailableCallback(&mock_callback()));
 
     net::TestURLFetcher* fetcher = fetcher_factory.GetLastCreatedFetcher();
     ASSERT_THAT(fetcher, NotNull());
     EXPECT_THAT(fetcher->GetMaxRetriesOn5xx(), Eq(retry_config.expected_value))
         << retry_config.description;
   }
 }
 
-TEST_F(NTPSnippetsFetcherTest, ShouldReportUrlStatusError) {
+TEST_F(ChromeReaderSnippetsFetcherTest, ShouldReportUrlStatusError) {
   SetFakeResponse(/*response_data=*/std::string(), net::HTTP_NOT_FOUND,
                   net::URLRequestStatus::FAILED);
   EXPECT_CALL(mock_callback(),
               Run(NTPSnippetsFetcher::FetchResult::URL_REQUEST_STATUS_ERROR,
                   /*snippets=*/Not(HasValue())))
       .Times(1);
   snippets_fetcher().FetchSnippets(
       test_params(), ToSnippetsAvailableCallback(&mock_callback()));
   FastForwardUntilNoTasksRemain();
   EXPECT_THAT(snippets_fetcher().last_status(),
               Eq("URLRequestStatus error -2"));
   EXPECT_THAT(snippets_fetcher().last_json(), IsEmpty());
   EXPECT_THAT(
       histogram_tester().GetAllSamples("NewTabPage.Snippets.FetchResult"),
       ElementsAre(base::Bucket(/*min=*/2, /*count=*/1)));
   EXPECT_THAT(histogram_tester().GetAllSamples(
                   "NewTabPage.Snippets.FetchHttpResponseOrErrorCode"),
               ElementsAre(base::Bucket(/*min=*/-2, /*count=*/1)));
   EXPECT_THAT(histogram_tester().GetAllSamples("NewTabPage.Snippets.FetchTime"),
               Not(IsEmpty()));
 }
 
-TEST_F(NTPSnippetsFetcherTest, ShouldReportHttpError) {
+TEST_F(ChromeReaderSnippetsFetcherTest, ShouldReportHttpError) {
   SetFakeResponse(/*response_data=*/std::string(), net::HTTP_NOT_FOUND,
                   net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(mock_callback(), Run(NTPSnippetsFetcher::FetchResult::HTTP_ERROR,
                                    /*snippets=*/Not(HasValue())))
       .Times(1);
   snippets_fetcher().FetchSnippets(
       test_params(), ToSnippetsAvailableCallback(&mock_callback()));
   FastForwardUntilNoTasksRemain();
   EXPECT_THAT(snippets_fetcher().last_json(), IsEmpty());
   EXPECT_THAT(
       histogram_tester().GetAllSamples("NewTabPage.Snippets.FetchResult"),
       ElementsAre(base::Bucket(/*min=*/3, /*count=*/1)));
   EXPECT_THAT(histogram_tester().GetAllSamples(
                   "NewTabPage.Snippets.FetchHttpResponseOrErrorCode"),
               ElementsAre(base::Bucket(/*min=*/404, /*count=*/1)));
   EXPECT_THAT(histogram_tester().GetAllSamples("NewTabPage.Snippets.FetchTime"),
               Not(IsEmpty()));
 }
 
-TEST_F(NTPSnippetsFetcherTest, ShouldReportJsonError) {
+TEST_F(ChromeReaderSnippetsFetcherTest, ShouldReportJsonError) {
   const std::string kInvalidJsonStr = "{ \"recos\": []";
   SetFakeResponse(/*response_data=*/kInvalidJsonStr, net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(mock_callback(),
               Run(NTPSnippetsFetcher::FetchResult::JSON_PARSE_ERROR,
                   /*snippets=*/Not(HasValue())))
       .Times(1);
   snippets_fetcher().FetchSnippets(
       test_params(), ToSnippetsAvailableCallback(&mock_callback()));
   FastForwardUntilNoTasksRemain();
   EXPECT_THAT(snippets_fetcher().last_status(),
               StartsWith("Received invalid JSON (error "));
   EXPECT_THAT(snippets_fetcher().last_json(), Eq(kInvalidJsonStr));
   EXPECT_THAT(
       histogram_tester().GetAllSamples("NewTabPage.Snippets.FetchResult"),
       ElementsAre(base::Bucket(/*min=*/4, /*count=*/1)));
   EXPECT_THAT(histogram_tester().GetAllSamples(
                   "NewTabPage.Snippets.FetchHttpResponseOrErrorCode"),
               ElementsAre(base::Bucket(/*min=*/200, /*count=*/1)));
   EXPECT_THAT(histogram_tester().GetAllSamples("NewTabPage.Snippets.FetchTime"),
               ElementsAre(base::Bucket(/*min=*/kTestJsonParsingLatencyMs,
                                        /*count=*/1)));
 }
 
-TEST_F(NTPSnippetsFetcherTest, ShouldReportJsonErrorForEmptyResponse) {
+TEST_F(ChromeReaderSnippetsFetcherTest, ShouldReportJsonErrorForEmptyResponse) {
   SetFakeResponse(/*response_data=*/std::string(), net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(mock_callback(),
               Run(NTPSnippetsFetcher::FetchResult::JSON_PARSE_ERROR,
                   /*snippets=*/Not(HasValue())))
       .Times(1);
   snippets_fetcher().FetchSnippets(
       test_params(), ToSnippetsAvailableCallback(&mock_callback()));
   FastForwardUntilNoTasksRemain();
   EXPECT_THAT(snippets_fetcher().last_json(), std::string());
   EXPECT_THAT(
       histogram_tester().GetAllSamples("NewTabPage.Snippets.FetchResult"),
       ElementsAre(base::Bucket(/*min=*/4, /*count=*/1)));
   EXPECT_THAT(histogram_tester().GetAllSamples(
                   "NewTabPage.Snippets.FetchHttpResponseOrErrorCode"),
               ElementsAre(base::Bucket(/*min=*/200, /*count=*/1)));
 }
 
-TEST_F(NTPSnippetsFetcherTest, ShouldReportInvalidListError) {
+TEST_F(ChromeReaderSnippetsFetcherTest, ShouldReportInvalidListError) {
   const std::string kJsonStr =
       "{\"recos\": [{ \"contentInfo\": { \"foo\" : \"bar\" }}]}";
   SetFakeResponse(/*response_data=*/kJsonStr, net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(
       mock_callback(),
       Run(NTPSnippetsFetcher::FetchResult::INVALID_SNIPPET_CONTENT_ERROR,
           /*snippets=*/Not(HasValue())))
       .Times(1);
   snippets_fetcher().FetchSnippets(
       test_params(), ToSnippetsAvailableCallback(&mock_callback()));
   FastForwardUntilNoTasksRemain();
   EXPECT_THAT(snippets_fetcher().last_json(), Eq(kJsonStr));
   EXPECT_THAT(
       histogram_tester().GetAllSamples("NewTabPage.Snippets.FetchResult"),
       ElementsAre(base::Bucket(/*min=*/5, /*count=*/1)));
   EXPECT_THAT(histogram_tester().GetAllSamples(
                   "NewTabPage.Snippets.FetchHttpResponseOrErrorCode"),
               ElementsAre(base::Bucket(/*min=*/200, /*count=*/1)));
   EXPECT_THAT(histogram_tester().GetAllSamples("NewTabPage.Snippets.FetchTime"),
               Not(IsEmpty()));
 }
 
 // This test actually verifies that the test setup itself is sane, to prevent
 // hard-to-reproduce test failures.
-TEST_F(NTPSnippetsFetcherTest, ShouldReportHttpErrorForMissingBakedResponse) {
+TEST_F(ChromeReaderSnippetsFetcherTest,
+       ShouldReportHttpErrorForMissingBakedResponse) {
   InitFakeURLFetcherFactory();
   EXPECT_CALL(mock_callback(),
               Run(NTPSnippetsFetcher::FetchResult::URL_REQUEST_STATUS_ERROR,
                   /*snippets=*/Not(HasValue())))
       .Times(1);
   snippets_fetcher().FetchSnippets(
       test_params(), ToSnippetsAvailableCallback(&mock_callback()));
   FastForwardUntilNoTasksRemain();
 }
 
-TEST_F(NTPSnippetsFetcherTest, ShouldProcessConcurrentFetches) {
+TEST_F(ChromeReaderSnippetsFetcherTest, ShouldProcessConcurrentFetches) {
   const std::string kJsonStr = "{ \"recos\": [] }";
   SetFakeResponse(/*response_data=*/kJsonStr, net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(mock_callback(), Run(NTPSnippetsFetcher::FetchResult::SUCCESS,
                                    IsEmptyArticleList()))
       .Times(5);
   snippets_fetcher().FetchSnippets(
       test_params(), ToSnippetsAvailableCallback(&mock_callback()));
   // More calls to FetchSnippets() do not interrupt the previous.
   // Callback is expected to be called once each time.
@@ skipping 22 matching lines @@
     const NTPSnippetsFetcher::OptionalFetchedCategories& fetched_categories) {
   if (fetched_categories) {
     // Matchers above aren't any more precise than this, so this is sufficient
     // for test-failure diagnostics.
     return os << "list with " << fetched_categories->size() << " elements";
   }
   return os << "null";
 }
 
 }  // namespace ntp_snippets