[Doodle] Split DoodleFetcher into interface + Impl

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.h"
+#include "components/doodle/doodle_fetcher_impl.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/test/simple_test_clock.h"
@@ skipping 45 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 DoodleFetcherTest : public testing::Test {
+class DoodleFetcherImplTest : public testing::Test {
  public:
-  DoodleFetcherTest()
+  DoodleFetcherImplTest()
       : url_(GURL(GoogleURLTracker::kDefaultGoogleHomepage)),
         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)) {
     // Random difference to ensure that expiry_dates are really relative.
     auto clock = base::MakeUnique<base::SimpleTestClock>();
     clock_ = clock.get();
@@ skipping 22 matching lines @@
     url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
   }
 
   net::TestURLFetcher* GetRunningFetcher() {
     // All created TestURLFetchers have ID 0 by default.
     net::TestURLFetcher* url_fetcher = url_fetcher_factory_.GetFetcherByID(0);
     DCHECK(url_fetcher);
     return url_fetcher;
   }
 
-  DoodleFetcher::FinishedCallback CreateResponseSavingCallback(
+  DoodleFetcherImpl::FinishedCallback CreateResponseSavingCallback(
       DoodleState* state_out,
       base::Optional<DoodleConfig>* config_out) {
     return base::BindOnce(
         [](DoodleState* state_out, base::Optional<DoodleConfig>* config_out,
            DoodleState state, const base::Optional<DoodleConfig>& config) {
           if (state_out) {
             *state_out = state;
           }
           if (config_out) {
             *config_out = config;
           }
         },
         state_out, config_out);
   }
 
-  DoodleFetcher* doodle_fetcher() { return &doodle_fetcher_; }
+  DoodleFetcherImpl* doodle_fetcher() { return &doodle_fetcher_; }
 
   GURL GetGoogleBaseURL() { return google_url_tracker_.google_url(); }
 
   base::Time TimeFromNow(uint64_t milliseconds) {
     return clock_->Now() + base::TimeDelta::FromMilliseconds(milliseconds);
   }
 
  private:
   base::MessageLoop message_loop_;
   GURL url_;
   net::TestURLFetcherFactory url_fetcher_factory_;
   base::SimpleTestClock* clock_;  // Owned by the doodle_fetcher.
   GoogleURLTracker google_url_tracker_;
-  DoodleFetcher doodle_fetcher_;
+  DoodleFetcherImpl doodle_fetcher_;
 };
 
-TEST_F(DoodleFetcherTest, ReturnsFromFetchWithoutError) {
+TEST_F(DoodleFetcherImplTest, ReturnsFromFetchWithoutError) {
   DoodleState state(DoodleState::NO_DOODLE);
   base::Optional<DoodleConfig> response;
 
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(&state, &response));
   RespondWithData(R"json({"ddljson": {
         "time_to_live_ms":55000,
         "large_image": {"url":"/logos/doodles/2015/some.gif"}
       }})json");
 
   EXPECT_THAT(state, Eq(DoodleState::AVAILABLE));
   EXPECT_TRUE(response.has_value());
 }
 
-TEST_F(DoodleFetcherTest, ReturnsFrom404FetchWithError) {
+TEST_F(DoodleFetcherImplTest, ReturnsFrom404FetchWithError) {
   DoodleState state(DoodleState::NO_DOODLE);
   base::Optional<DoodleConfig> response;
 
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(&state, &response));
   RespondWithError(net::ERR_FILE_NOT_FOUND);
 
   EXPECT_THAT(state, Eq(DoodleState::DOWNLOAD_ERROR));
   EXPECT_FALSE(response.has_value());
 }
 
-TEST_F(DoodleFetcherTest, ReturnsErrorForInvalidJson) {
+TEST_F(DoodleFetcherImplTest, ReturnsErrorForInvalidJson) {
   DoodleState state(DoodleState::NO_DOODLE);
   base::Optional<DoodleConfig> response;
 
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(&state, &response));
   RespondWithData("}");
 
   EXPECT_THAT(state, Eq(DoodleState::PARSING_ERROR));
   EXPECT_FALSE(response.has_value());
 }
 
-TEST_F(DoodleFetcherTest, ReturnsErrorForIncompleteJson) {
+TEST_F(DoodleFetcherImplTest, ReturnsErrorForIncompleteJson) {
   DoodleState state(DoodleState::NO_DOODLE);
   base::Optional<DoodleConfig> response;
 
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(&state, &response));
   RespondWithData("{}");
 
   EXPECT_THAT(state, Eq(DoodleState::PARSING_ERROR));
   EXPECT_FALSE(response.has_value());
 }
 
-TEST_F(DoodleFetcherTest, ResponseContainsValidBaseInformation) {
+TEST_F(DoodleFetcherImplTest, ResponseContainsValidBaseInformation) {
   DoodleState state(DoodleState::NO_DOODLE);
   base::Optional<DoodleConfig> response;
 
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(&state, &response));
   RespondWithData(R"json()]}'{
       "ddljson": {
         "alt_text":"Mouseover Text",
         "doodle_type":"SIMPLE",
         "interactive_html":"\u003cstyle\u003e\u003c\/style\u003e",
@@ skipping 17 matching lines @@
               Eq(Resolve("/search?q\u003dtest\u0026sa\u003dX\u0026ved\u003d"
                          "0ahUKEw")));
   EXPECT_THAT(config.doodle_type, Eq(DoodleType::SIMPLE));
   EXPECT_THAT(config.alt_text, Eq("Mouseover Text"));
   EXPECT_THAT(config.interactive_html,
               Eq("\u003cstyle\u003e\u003c/style\u003e"));
 
   EXPECT_THAT(config.expiry_date, Eq(TimeFromNow(55000)));
 }
 
-TEST_F(DoodleFetcherTest, DoodleExpiresWithinThirtyDaysForTooLargeTTL) {
+TEST_F(DoodleFetcherImplTest, DoodleExpiresWithinThirtyDaysForTooLargeTTL) {
   DoodleState state(DoodleState::NO_DOODLE);
   base::Optional<DoodleConfig> response;
 
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(&state, &response));
   RespondWithData(R"json({"ddljson": {
       "time_to_live_ms":5184000000,
       "large_image": {"url":"/logos/doodles/2015/some.gif"}
     }})json");  // 60 days
 
   EXPECT_THAT(state, Eq(DoodleState::AVAILABLE));
   ASSERT_TRUE(response.has_value());
   EXPECT_THAT(response.value().expiry_date,
               Eq(TimeFromNow(30ul * 24 * 60 * 60 * 1000 /* ms */)));  // 30 days
 }
 
-TEST_F(DoodleFetcherTest, DoodleExpiresNowWithNegativeTTL) {
+TEST_F(DoodleFetcherImplTest, DoodleExpiresNowWithNegativeTTL) {
   DoodleState state(DoodleState::NO_DOODLE);
   base::Optional<DoodleConfig> response;
 
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(&state, &response));
   RespondWithData(R"json({"ddljson": {
       "time_to_live_ms":-1,
       "large_image": {"url":"/logos/doodles/2015/some.gif"}
     }})json");
 
   EXPECT_THAT(state, Eq(DoodleState::AVAILABLE));
   ASSERT_TRUE(response.has_value());
   EXPECT_THAT(response.value().expiry_date, Eq(TimeFromNow(0)));
 }
 
-TEST_F(DoodleFetcherTest, DoodleExpiresNowWithoutValidTTL) {
+TEST_F(DoodleFetcherImplTest, DoodleExpiresNowWithoutValidTTL) {
   DoodleState state(DoodleState::NO_DOODLE);
   base::Optional<DoodleConfig> response;
 
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(&state, &response));
   RespondWithData(R"json({"ddljson": {
         "large_image": {"url":"/logos/doodles/2015/some.gif"}
       }})json");
 
   EXPECT_THAT(state, Eq(DoodleState::AVAILABLE));
   ASSERT_TRUE(response.has_value());
   EXPECT_THAT(response.value().expiry_date, Eq(TimeFromNow(0)));
 }
 
-TEST_F(DoodleFetcherTest, ReturnsNoDoodleForMissingLargeImageUrl) {
+TEST_F(DoodleFetcherImplTest, ReturnsNoDoodleForMissingLargeImageUrl) {
   DoodleState state(DoodleState::AVAILABLE);
   base::Optional<DoodleConfig> response;
 
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(&state, &response));
   RespondWithData(R"json({"ddljson": {
         "time_to_live_ms":55000,
         "large_image": {}
       }})json");
 
   EXPECT_THAT(state, Eq(DoodleState::NO_DOODLE));
   EXPECT_FALSE(response.has_value());
 }
 
-TEST_F(DoodleFetcherTest, EmptyResponsesCausesNoDoodleState) {
+TEST_F(DoodleFetcherImplTest, EmptyResponsesCausesNoDoodleState) {
   DoodleState state(DoodleState::AVAILABLE);
   base::Optional<DoodleConfig> response;
 
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(&state, &response));
   RespondWithData("{\"ddljson\":{}}");
 
   EXPECT_THAT(state, Eq(DoodleState::NO_DOODLE));
   EXPECT_FALSE(response.has_value());
 }
 
-TEST_F(DoodleFetcherTest, ResponseContainsExactlyTheSampleImages) {
+TEST_F(DoodleFetcherImplTest, ResponseContainsExactlyTheSampleImages) {
   DoodleState state(DoodleState::NO_DOODLE);
   base::Optional<DoodleConfig> response;
 
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(&state, &response));
   RespondWithData(R"json()]}'{
       "ddljson": {
         "time_to_live_ms":55000,
         "large_image": {
           "height":225,
@@ skipping 43 matching lines @@
   EXPECT_TRUE(config.large_cta_image.url.is_valid());
   EXPECT_THAT(config.large_cta_image.url.spec(),
               Eq(Resolve("/logos/doodles/2015/new-years-eve-2015-5985438795"
                          "8251-cta.gif")));
   EXPECT_THAT(config.large_cta_image.width, Eq(489));
   EXPECT_THAT(config.large_cta_image.height, Eq(225));
   EXPECT_TRUE(config.large_cta_image.is_animated_gif);
   EXPECT_TRUE(config.large_cta_image.is_cta);
 }
 
-TEST_F(DoodleFetcherTest, RespondsToMultipleRequestsWithSameFetcher) {
+TEST_F(DoodleFetcherImplTest, RespondsToMultipleRequestsWithSameFetcher) {
   DoodleState state1(DoodleState::NO_DOODLE);
   DoodleState state2(DoodleState::NO_DOODLE);
   base::Optional<DoodleConfig> response1;
   base::Optional<DoodleConfig> response2;
 
   // Trigger two requests.
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(&state1, &response1));
   net::URLFetcher* first_created_fetcher = GetRunningFetcher();
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(&state2, &response2));
   net::URLFetcher* second_created_fetcher = GetRunningFetcher();
 
   // Expect that only one fetcher handles both requests.
   EXPECT_THAT(first_created_fetcher, Eq(second_created_fetcher));
 
   RespondWithData(R"json({"ddljson": {
         "time_to_live_ms":55000,
         "large_image": {"url":"/logos/doodles/2015/some.gif"}
       }})json");
 
   // Ensure that both requests received a response.
   EXPECT_THAT(state1, Eq(DoodleState::AVAILABLE));
   EXPECT_TRUE(response1.has_value());
   EXPECT_THAT(state2, Eq(DoodleState::AVAILABLE));
   EXPECT_TRUE(response2.has_value());
 }
 
-TEST_F(DoodleFetcherTest, ReceivesBaseUrlFromTracker) {
+TEST_F(DoodleFetcherImplTest, ReceivesBaseUrlFromTracker) {
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(/*state=*/nullptr, /*response=*/nullptr));
 
   EXPECT_THAT(GetRunningFetcher()->GetOriginalURL(),
               Eq(GetGoogleBaseURL().Resolve(kDoodleConfigPath)));
 }
 
-TEST_F(DoodleFetcherTest, OverridesBaseUrlWithCommandLineArgument) {
+TEST_F(DoodleFetcherImplTest, OverridesBaseUrlWithCommandLineArgument) {
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kGoogleBaseURL, "http://www.google.kz");
 
   doodle_fetcher()->FetchDoodle(
       CreateResponseSavingCallback(/*state=*/nullptr, /*response=*/nullptr));
 
   EXPECT_THAT(GetRunningFetcher()->GetOriginalURL(),
               Eq(GURL("http://www.google.kz").Resolve(kDoodleConfigPath)));
 }
 
 }  // namespace doodle