Generate snippets request JSON with base::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"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/ntp_snippets/ntp_snippet.h"
 #include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/fake_profile_oauth2_token_service.h"
 #include "components/signin/core/browser/fake_signin_manager.h"
 #include "components/signin/core/browser/test_signin_client.h"
 #include "google_apis/google_api_keys.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace ntp_snippets {
+
 namespace {
 
 using testing::ElementsAre;
 using testing::Eq;
 using testing::IsEmpty;
 using testing::IsNull;
 using testing::Not;
 using testing::NotNull;
 using testing::PrintToString;
 using testing::SizeIs;
 using testing::StartsWith;
 
 const char kTestContentSnippetsServerFormat[] =
     "https://chromereader-pa.googleapis.com/v1/fetch?key=%s";
 // Artificial time delay for JSON parsing.
 const int64_t kTestJsonParsingLatencyMs = 20;
 
 MATCHER(HasValue, "") {
   return static_cast<bool>(arg);
 }
 
 MATCHER_P(PointeeSizeIs,
           size,
           std::string("contains a value with size ") + PrintToString(size)) {
   return arg && static_cast<int>(arg->size()) == size;
 }
 
+MATCHER_P(EqualsJSON, json, "equals JSON") {
+  std::unique_ptr<base::Value> expected = base::JSONReader::Read(json);
+  if (!expected) {
+    *result_listener << "INTERNAL ERROR: couldn't parse expected JSON";
+    return false;
+  }
+
+  std::string err_msg;
+  int err_line, err_col;
+  std::unique_ptr<base::Value> actual = base::JSONReader::ReadAndReturnError(
+      arg, base::JSON_PARSE_RFC, nullptr, &err_msg, &err_line, &err_col);
+  if (!actual) {
+    *result_listener << "input:" << err_line << ":" << err_col << ": "
+                     << "parse error: " << err_msg;
+    return false;
+  }
+  return base::Value::Equals(actual.get(), expected.get());
+}
+
 class MockSnippetsAvailableCallback {
  public:
   // Workaround for gMock's lack of support for movable arguments.
   void WrappedRun(NTPSnippetsFetcher::OptionalSnippets snippets) {
     Run(snippets);
   }
 
   MOCK_METHOD1(Run, void(const NTPSnippetsFetcher::OptionalSnippets& snippets));
 };
 
@@ skipping 23 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));
 }
 
+}  // namespace
+
 class NTPSnippetsFetcherTest : public testing::Test {
  public:
   NTPSnippetsFetcherTest()
       : 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()),
@@ skipping 57 matching lines @@
   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);
 };
 
+TEST_F(NTPSnippetsFetcherTest, BuildRequestAuthenticated) {
+  EXPECT_THAT(NTPSnippetsFetcher::BuildRequest("0BFUSGAIA", true, "en",
+                                               {"chromium.org"}, 25),
+              EqualsJSON("{"
+                         "  \"response_detail_level\": \"STANDARD\","
+                         "  \"obfuscated_gaia_id\": \"0BFUSGAIA\","
+                         "  \"advanced_options\": {"
+                         "    \"local_scoring_params\": {"
+                         "      \"content_params\": {"
+                         "        \"only_return_personalized_results\": true,"
+                         "        \"user_segment\": \"en\""
+                         "      },"
+                         "      \"content_restricts\": ["
+                         "        {"
+                         "          \"type\": \"METADATA\","
+                         "          \"value\": \"TITLE\""
+                         "        },"
+                         "        {"
+                         "          \"type\": \"METADATA\","
+                         "          \"value\": \"SNIPPET\""
+                         "        },"
+                         "        {"
+                         "          \"type\": \"METADATA\","
+                         "          \"value\": \"THUMBNAIL\""
+                         "        }"
+                         "      ],"
+                         "      \"content_selectors\": ["
+                         "        {"
+                         "          \"type\": \"HOST_RESTRICT\","
+                         "          \"value\": \"chromium.org\""
+                         "        }"
+                         "      ]"
+                         "    },"
+                         "    \"global_scoring_params\": {"
+                         "      \"num_to_return\": 25,"
+                         "      \"sort_type\": 1"
+                         "    }"
+                         "  }"
+                         "}"));
+}
+
+TEST_F(NTPSnippetsFetcherTest, BuildRequestUnauthenticated) {
+  EXPECT_THAT(NTPSnippetsFetcher::BuildRequest("", false, "",
+                                               std::set<std::string>(), 10),
+              EqualsJSON("{"
+                         "  \"response_detail_level\": \"STANDARD\","
+                         "  \"advanced_options\": {"
+                         "    \"local_scoring_params\": {"
+                         "      \"content_params\": {"
+                         "        \"only_return_personalized_results\": false"
+                         "      },"
+                         "      \"content_restricts\": ["
+                         "        {"
+                         "          \"type\": \"METADATA\","
+                         "          \"value\": \"TITLE\""
+                         "        },"
+                         "        {"
+                         "          \"type\": \"METADATA\","
+                         "          \"value\": \"SNIPPET\""
+                         "        },"
+                         "        {"
+                         "          \"type\": \"METADATA\","
+                         "          \"value\": \"THUMBNAIL\""
+                         "        }"
+                         "      ],"
+                         "      \"content_selectors\": []"
+                         "    },"
+                         "    \"global_scoring_params\": {"
+                         "      \"num_to_return\": 10,"
+                         "      \"sort_type\": 1"
+                         "    }"
+                         "  }"
+                         "}"));
+}
+
 TEST_F(NTPSnippetsFetcherTest, 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());
 }
@@ skipping 216 matching lines @@
       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)));
   EXPECT_THAT(histogram_tester().GetAllSamples("NewTabPage.Snippets.FetchTime"),
               ElementsAre(base::Bucket(/*min=*/kTestJsonParsingLatencyMs,
                                        /*count=*/1)));
 }
 
-}  // namespace
 }  // namespace ntp_snippets