More unittests of ntp_snippets_fetcher that depend on trial param value.

components/ntp_snippets/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/ntp_snippets_fetcher.h"
 
 #include "base/json/json_reader.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/histogram_tester.h"
@@ skipping 105 matching lines @@
 
 void ParseJsonDelayed(
     const std::string& json,
     const ntp_snippets::NTPSnippetsFetcher::SuccessCallback& success_callback,
     const ntp_snippets::NTPSnippetsFetcher::ErrorCallback& error_callback) {
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&ParseJson, json, success_callback, error_callback),
       base::TimeDelta::FromMilliseconds(kTestJsonParsingLatencyMs));
 }
 
-class VariationParams {
- public:
-  VariationParams(const std::string& trial_name,
-                  const std::map<std::string, std::string>& params)
-      : field_trial_list_(new metrics::SHA1EntropyProvider("foo")) {
-    variations::AssociateVariationParams(trial_name, "Group1", params);
-    base::FieldTrialList::CreateFieldTrial(trial_name, "Group1");
-  }
-
-  ~VariationParams() { variations::testing::ClearAllVariationParams(); }
-
- private:
-  base::FieldTrialList field_trial_list_;
-};
+GURL GetFetcherUrl(const char* url_format) {
+  return GURL(base::StringPrintf(url_format, google_apis::GetAPIKey().c_str()));
+}
 
 }  // namespace
 
 class NTPSnippetsFetcherTest : public testing::Test {
  public:
   NTPSnippetsFetcherTest()
       : NTPSnippetsFetcherTest(
-            GURL(base::StringPrintf(kTestChromeReaderUrlFormat,
-                                    google_apis::GetAPIKey().c_str())),
+            GetFetcherUrl(kTestChromeReaderUrlFormat),
             std::map<std::string, std::string>()) {}
 
   NTPSnippetsFetcherTest(const GURL& gurl,
                          const std::map<std::string, std::string>& params)
-      : params_(ntp_snippets::kStudyName, params),
+      : params_manager_(ntp_snippets::kStudyName, params),
         mock_task_runner_(new base::TestMockTimeTaskRunner()),
         mock_task_runner_handle_(mock_task_runner_),
         signin_client_(new TestSigninClient(nullptr)),
         account_tracker_(new AccountTrackerService()),
         fake_signin_manager_(new FakeSigninManagerBase(signin_client_.get(),
                                                        account_tracker_.get())),
         fake_token_service_(new FakeProfileOAuth2TokenService()),
         snippets_fetcher_(
             fake_signin_manager_.get(),
             fake_token_service_.get(),
@@ skipping 34 matching lines @@
 
   void SetFakeResponse(const std::string& response_data,
                        net::HttpStatusCode response_code,
                        net::URLRequestStatus::Status status) {
     InitFakeURLFetcherFactory();
     fake_url_fetcher_factory_->SetFakeResponse(test_url_, response_data,
                                                response_code, status);
   }
 
  private:
-  VariationParams params_;
+  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_;
   NTPSnippetsFetcher snippets_fetcher_;
   MockSnippetsAvailableCallback mock_callback_;
   const std::string test_lang_;
   const GURL test_url_;
   std::set<std::string> test_hosts_;
   base::HistogramTester histogram_tester_;
 
   DISALLOW_COPY_AND_ASSIGN(NTPSnippetsFetcherTest);
 };
 
 class NTPSnippetsContentSuggestionsFetcherTest : public NTPSnippetsFetcherTest {
  public:
   NTPSnippetsContentSuggestionsFetcherTest()
       : NTPSnippetsFetcherTest(
-            GURL(base::StringPrintf(kTestChromeContentSuggestionsUrlFormat,
-                                    google_apis::GetAPIKey().c_str())),
+            GetFetcherUrl(kTestChromeContentSuggestionsUrlFormat),
             std::map<std::string, std::string>{
                 {"content_suggestions_backend", kContentSuggestionsBackend}}) {}
 };
 
+class NTPSnippetsFetcherHostRestrictedTest : public NTPSnippetsFetcherTest {
+ public:
+  NTPSnippetsFetcherHostRestrictedTest()
+      : NTPSnippetsFetcherTest(
+            GetFetcherUrl(kTestChromeReaderUrlFormat),
+            std::map<std::string, std::string>{
+                {"fetching_host_restrict", "on"}}) {}

[Marc Treib, 2016/07/20 08:34:45]

Out of curiosity: Is the "std::map<...>" required here (and above), or could you
just pass the initializer list?

[jkrcal, 2016/07/20 12:17:31]

You are right, not needed. Thanks!

+};
+
 TEST_F(NTPSnippetsFetcherTest, BuildRequestAuthenticated) {
   NTPSnippetsFetcher::RequestParams params;
   params.obfuscated_gaia_id = "0BFUSGAIA";
   params.only_return_personalized_results = true;
   params.user_locale = "en";
   params.host_restricts = {"chromium.org"};
   params.count_to_fetch = 25;
 
   params.fetch_api = NTPSnippetsFetcher::CHROME_READER_API;
   EXPECT_THAT(params.BuildRequest(),
@@ skipping 169 matching lines @@
   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)));
 }
 
-// TODO(jkrcal) Return the tests ShouldReportEmptyHostsError and
-// ShouldRestrictToHosts once we have a way to change variation parameters from
-// unittests. The tests were tailored to previous default value of the parameter
-// fetching_host_restrict, which changed now.
+TEST_F(NTPSnippetsFetcherHostRestrictedTest, ShouldReportEmptyHostsError) {
+  EXPECT_CALL(mock_callback(), Run(/*snippets=*/Not(HasValue()))).Times(1);
+  snippets_fetcher().FetchSnippetsFromHosts(/*hosts=*/std::set<std::string>(),
+                                            /*language_code=*/"en-US",
+                                            /*count=*/1);
+  FastForwardUntilNoTasksRemain();
+  EXPECT_THAT(snippets_fetcher().last_status(),
+              Eq("Cannot fetch for empty hosts list."));
+  EXPECT_THAT(snippets_fetcher().last_json(), IsEmpty());
+  EXPECT_THAT(
+      histogram_tester().GetAllSamples("NewTabPage.Snippets.FetchResult"),
+      ElementsAre(base::Bucket(/*min=*/1, /*count=*/1)));
+  EXPECT_THAT(histogram_tester().GetAllSamples(
+                  "NewTabPage.Snippets.FetchHttpResponseOrErrorCode"),
+              IsEmpty());
+  // This particular error gets triggered prior to JSON parsing and hence tests
+  // observe no fetch latency.
+  EXPECT_THAT(histogram_tester().GetAllSamples("NewTabPage.Snippets.FetchTime"),
+              ElementsAre(base::Bucket(/*min=*/0, /*count=*/1)));
+}
+
+TEST_F(NTPSnippetsFetcherHostRestrictedTest, ShouldRestrictToHosts) {
+  net::TestURLFetcherFactory test_url_fetcher_factory;
+  snippets_fetcher().FetchSnippetsFromHosts(
+      {"www.somehost1.com", "www.somehost2.com"}, test_lang(), /*count=*/17);
+  net::TestURLFetcher* fetcher = test_url_fetcher_factory.GetFetcherByID(0);
+  ASSERT_THAT(fetcher, NotNull());
+  std::unique_ptr<base::Value> value =
+      base::JSONReader::Read(fetcher->upload_data());
+  ASSERT_TRUE(value) << " failed to parse JSON: "
+                     << PrintToString(fetcher->upload_data());
+  const base::DictionaryValue* dict = nullptr;
+  ASSERT_TRUE(value->GetAsDictionary(&dict));
+  const base::DictionaryValue* local_scoring_params = nullptr;
+  ASSERT_TRUE(dict->GetDictionary("advanced_options.local_scoring_params",
+                                  &local_scoring_params));
+  const base::ListValue* content_selectors = nullptr;
+  ASSERT_TRUE(
+      local_scoring_params->GetList("content_selectors", &content_selectors));
+  ASSERT_THAT(content_selectors->GetSize(), Eq(static_cast<size_t>(2)));
+  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, ShouldReportUrlStatusError) {
   SetFakeResponse(/*data=*/std::string(), net::HTTP_NOT_FOUND,
                   net::URLRequestStatus::FAILED);
   EXPECT_CALL(mock_callback(), Run(/*snippets=*/Not(HasValue()))).Times(1);
   snippets_fetcher().FetchSnippetsFromHosts(test_hosts(), test_lang(),
                                             /*count=*/1);
   FastForwardUntilNoTasksRemain();
   EXPECT_THAT(snippets_fetcher().last_status(),
               Eq("URLRequestStatus error -2"));
   EXPECT_THAT(snippets_fetcher().last_json(), IsEmpty());
@@ skipping 122 matching lines @@
   if (snippets) {
     // Matchers above aren't any more precise than this, so this is sufficient
     // for test-failure diagnostics.
     return os << "list with " << snippets->size() << " elements";
   } else {
     return os << "null";
   }
 }
 
 }  // namespace ntp_snippets