[Doodle] Pass parameters to the server endpoint

components/doodle/doodle_fetcher_impl_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/doodle/doodle_fetcher_impl.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
@@ skipping 16 matching lines @@
 
 using testing::_;
 using testing::DoAll;
 using testing::Eq;
 using testing::SaveArg;
 
 namespace doodle {
 
 namespace {
 
-const char kDoodleConfigPath[] = "/async/ddljson";
+const char kDoodleConfigPath[] = "/async/ddljson?async=ntp:1,graybg:1";
+const char kDoodleConfigPathNoGrayBg[] = "/async/ddljson?async=ntp:1,graybg:0";
 
 // Required to instantiate a GoogleUrlTracker in UNIT_TEST_MODE.
 class GoogleURLTrackerClientStub : public GoogleURLTrackerClient {
  public:
   GoogleURLTrackerClientStub() {}
   ~GoogleURLTrackerClientStub() override {}
 
   bool IsBackgroundNetworkingEnabled() override { return true; }
 
   PrefService* GetPrefs() override { return nullptr; }
@@ skipping 12 matching lines @@
   std::unique_ptr<base::Value> value = json_reader.ReadToValue(json);
   if (value) {
     success.Run(std::move(value));
   } else {
     error.Run(json_reader.GetErrorMessage());
   }
 }
 
 }  // namespace
 
-class DoodleFetcherImplTest : public testing::Test {
+class DoodleFetcherImplTestBase : public testing::Test {
  public:
-  DoodleFetcherImplTest()
+  DoodleFetcherImplTestBase(bool gray_background)
       : google_url_tracker_(base::MakeUnique<GoogleURLTrackerClientStub>(),
                             GoogleURLTracker::UNIT_TEST_MODE),
         doodle_fetcher_(
             new net::TestURLRequestContextGetter(message_loop_.task_runner()),
             &google_url_tracker_,
-            base::Bind(ParseJson)) {}
+            base::Bind(ParseJson),
+            gray_background) {}
 
   void RespondWithData(const std::string& data) {
     net::TestURLFetcher* url_fetcher = GetRunningFetcher();
     url_fetcher->set_status(net::URLRequestStatus());
     url_fetcher->set_response_code(net::HTTP_OK);
     url_fetcher->SetResponseString(data);
     // Call the URLFetcher delegate to continue the test.
     url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
   }
 
@@ skipping 20 matching lines @@
     return GetGoogleBaseURL().Resolve(relative_url);
   }
 
  private:
   base::MessageLoop message_loop_;
   net::TestURLFetcherFactory url_fetcher_factory_;
   GoogleURLTracker google_url_tracker_;
   DoodleFetcherImpl doodle_fetcher_;
 };
 
+class DoodleFetcherImplTest : public DoodleFetcherImplTestBase {
+ public:
+  DoodleFetcherImplTest()
+      : DoodleFetcherImplTestBase(/*gray_background=*/true) {}
+};
+
 TEST_F(DoodleFetcherImplTest, ReturnsFromFetchWithoutError) {
   base::MockCallback<DoodleFetcherImpl::FinishedCallback> callback;
   doodle_fetcher()->FetchDoodle(callback.Get());
 
   DoodleState state = DoodleState::NO_DOODLE;
   base::Optional<DoodleConfig> response;
   EXPECT_CALL(callback, Run(_, _, _))
       .WillOnce(DoAll(SaveArg<0>(&state), SaveArg<2>(&response)));
   RespondWithData(R"json({"ddljson": {
         "time_to_live_ms":55000,
@@ skipping 287 matching lines @@
 }
 
 TEST_F(DoodleFetcherImplTest, ReceivesBaseUrlFromTracker) {
   base::MockCallback<DoodleFetcherImpl::FinishedCallback> callback;
   doodle_fetcher()->FetchDoodle(callback.Get());
 
   // TODO(treib,fhorschig): This doesn't really test anything useful, since the
   // Google base URL is the default anyway. Find a way to set the base URL in
   // the tracker.
   EXPECT_THAT(GetRunningFetcher()->GetOriginalURL(),
-              Eq(GetGoogleBaseURL().Resolve(kDoodleConfigPath)));
+              Eq(Resolve(kDoodleConfigPath)));
 }
 
 TEST_F(DoodleFetcherImplTest, OverridesBaseUrlWithCommandLineArgument) {
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kGoogleBaseURL, "http://www.google.kz");
 
   base::MockCallback<DoodleFetcherImpl::FinishedCallback> callback;
   doodle_fetcher()->FetchDoodle(callback.Get());
 
   EXPECT_THAT(GetRunningFetcher()->GetOriginalURL(),
               Eq(GURL("http://www.google.kz").Resolve(kDoodleConfigPath)));
 }
 
+class DoodleFetcherImplNoGrayBgTest : public DoodleFetcherImplTestBase {
+ public:
+  DoodleFetcherImplNoGrayBgTest()
+      : DoodleFetcherImplTestBase(/*gray_background=*/false) {}
+};
+
+TEST_F(DoodleFetcherImplNoGrayBgTest, PassesNoGrayBgParam) {
+  base::MockCallback<DoodleFetcherImpl::FinishedCallback> callback;
+  doodle_fetcher()->FetchDoodle(callback.Get());
+
+  EXPECT_THAT(GetRunningFetcher()->GetOriginalURL(),
+              Eq(Resolve(kDoodleConfigPathNoGrayBg)));
+}
+
 }  // namespace doodle