Introduce a Doodle Fetcher for NTP

components/doodle/doodle_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/doodle/doodle_fetcher.h"
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/files/file_util.h"
+#include "base/files/important_file_writer.h"
+#include "base/files/scoped_temp_dir.h"
+#include "base/json/json_reader.h"
+#include "base/json/json_writer.h"
+#include "base/memory/ptr_util.h"
+#include "base/run_loop.h"
+#include "base/test/sequenced_worker_pool_owner.h"
+#include "base/test/test_mock_time_task_runner.h"
+#include "base/threading/sequenced_task_runner_handle.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "base/values.h"
+#include "components/safe_json/testing_json_parser.h"
+#include "net/http/http_status_code.h"
+#include "net/url_request/test_url_fetcher_factory.h"
+#include "net/url_request/url_request_status.h"
+#include "net/url_request/url_request_test_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using testing::Eq;
+using testing::IsEmpty;
+
+namespace doodle {
+
+namespace {
+
+const char* kSampleResponse =
+    ")]}'{"

[Marc Treib, 2017/02/01 10:55:58]

You could use a raw string literal here, to avoid all the escaping.
Example:
https://cs.chromium.org/chromium/src/chrome/browser/chromeos/printing/printer...

[fhorschig, 2017/02/01 11:16:14]

Done.

+    "\"ddljson\": {"
+    "  \"alt_text\":\"Mouseover Text\","
+    "  \"doodle_type\":\"SIMPLE\","
+    "  \"gallery_url\":\"//www.google.com/doodles/burning-man-festival\","
+    "  \"header_layout\":\"LEGACY\","
+    "  \"hires_image\": {"
+    "    \"alternate_url\":\"\","
+    "    \"background_color\":\"#ffffff\","
+    "    \"height\":450,"
+    "    \"image_id\":0,"
+    "    \"image_name\":\"\","
+    "    \"is_animated_gif\":true,"
+    "    \"is_cta\":false,"
+    "    \"offset_x\":0,"
+    "    \"offset_y\":0,"
+    "    \"overlay_icon_color\":\"\","
+    "    \"size_type\":\"LARGE_2X\","
+    "    \"slot\":8,"
+    "    \"url\":\"/logos/doodles/2015/"
+    "new-years-eve-2015-5985438795825152-hp2x.gif\","
+    "    \"width\":978"
+    "  },"
+    "  \"id\":0,"
+    "  \"intent\":\"BUILTIN\","
+    "  \"large_image\": {"
+    "    \"alternate_url\":\"\","
+    "    \"background_color\":\"#ffffff\","
+    "    \"height\":225,"
+    "    \"image_id\":0,"
+    "    \"image_name\":\"\","
+    "    \"is_animated_gif\":true,"
+    "    \"is_cta\":false,"
+    "    \"offset_x\":0,"
+    "    \"offset_y\":0,"
+    "    \"overlay_icon_color\":\"\","
+    "    \"size_type\":\"LARGE\","
+    "    \"slot\":1,"
+    "    \"url\":\"/logos/doodles/2015/"
+    "new-years-eve-2015-5985438795825152-hp.gif\","
+    "    \"width\":489"
+    "  },"
+    "  \"medium_image\": {"
+    "    \"alternate_url\":\"\","
+    "    \"background_color\":\"#fff1b9\","
+    "    \"height\":128,"
+    "    \"image_id\":0,"
+    "    \"image_name\":\"\","
+    "    \"is_animated_gif\":false,"
+    "    \"is_cta\":true,"
+    "    \"offset_x\":0,"
+    "    \"offset_y\":0,"
+    "    \"overlay_icon_color\":\"#ff0f15\","
+    "    \"size_type\":\"LARGE_MOBILE_SRP\","
+    "    \"slot\":3,"
+    "    \"url\":\"/logos/doodles/2015/new-years-eve-2015-5985438795825152-m.pn"
+    "g\","
+    "    \"width\":291"
+    "  },"
+    "  \"search_url\":\"/search?q\u003dtest\","
+    "  \"share_text\":\"Share Text #GoogleDoodle\nhttps://g.co/doodle/8hfqzq\","
+    "  \"short_link\":\"//g.co/doodle/8hfqzq\","
+    "  \"show_now_header_search_affordance\":false,"
+    "  \"show_now_header_share_button\":true,"
+    "  \"small_image\": {"
+    "    \"alternate_url\":\"\","
+    "    \"background_color\":\"\","
+    "    \"height\":41,"
+    "    \"image_id\":0,"
+    "    \"image_name\":\"\","
+    "    \"is_animated_gif\":false,"
+    "    \"is_cta\":false,"
+    "    \"offset_x\":0,"
+    "    \"offset_y\":0,"
+    "    \"overlay_icon_color\":\"\","
+    "    \"size_type\":\"SMALL_DESKTOP_SRP\","
+    "    \"slot\":4,"
+    "    \"url\":\"/logos/doodles/2015/"
+    "new-years-eve-2015-5985438795825152.2-res.png\","
+    "  \"width\":95"
+    "  },"
+    "  \"target_url\":\"/search?q\u003dtest\u0026sa\u003dX\u0026ved\u003d0ahUKE"
+    "wjm9vmF8enRAhUJvBQKHX1CC54QNggB\","
+    "  \"time_to_live_ms\":514220215000,"
+    "  \"transparent_large_image\": {"
+    "    \"alternate_url\":\"\","
+    "    \"background_color\":\"\","
+    "    \"height\":225,"
+    "    \"image_id\":0,"
+    "    \"image_name\":\"\","
+    "    \"is_animated_gif\":false,"
+    "    \"is_cta\":false,"
+    "    \"offset_x\":0,"
+    "    \"offset_y\":0,"
+    "    \"overlay_icon_color\":\"\","
+    "    \"size_type\":\"LARGE\","
+    "    \"slot\":2,"
+    "    \"url\":\"/logos/doodles/2015/"
+    "new-years-eve-2015-5985438795825152-thp.png\","
+    "    \"width\":510"
+    "  }"
+    "}}";
+
+const char kBaseUrl[] = "https://www.google.com/";
+
+std::string AbsoluteUrl(const std::string& relative_url) {
+  return GURL(kBaseUrl).Resolve(relative_url).spec();
+}
+
+}  // namespace
+
+class DoodleFetcherTest : public ::testing::Test {
+ public:
+  DoodleFetcherTest()
+      : url_(GURL(kBaseUrl).Resolve(kDoodleConfigUrl)),
+        url_fetcher_factory_(nullptr),
+        mock_task_runner_(new base::TestMockTimeTaskRunner()),
+        mock_task_runner_handle_(mock_task_runner_),
+        context_getter(
+            new net::TestURLRequestContextGetter(mock_task_runner_.get())) {
+    // Random difference to 0 ensures that expiry_dates are really relative.
+    mock_task_runner_->FastForwardBy(base::TimeDelta::FromMilliseconds(80082));
+  }
+
+  void RespondWithData(const std::string& data) {
+    url_fetcher_factory_.SetFakeResponse(url_, data, net::HTTP_OK,
+                                         net::URLRequestStatus::SUCCESS);
+  }
+
+  void RespondWithError() {
+    url_fetcher_factory_.SetFakeResponse(url_, "", net::HTTP_NOT_FOUND,
+                                         net::URLRequestStatus::FAILED);
+  }
+
+  DoodleConfig FetchDoodle() {
+    DoodleConfig doodle(DoodleState::NO_DOODLE);
+    std::unique_ptr<DoodleFetcher> fetcher = CreateDoodleFetcher();
+    TriggerFetch(fetcher.get(), &doodle);
+    WaitForCallbacks();
+    return doodle;
+  }
+
+  std::unique_ptr<DoodleFetcher> CreateDoodleFetcher() {
+    std::unique_ptr<DoodleFetcher> fetcher =
+        base::MakeUnique<DoodleFetcher>(context_getter.get(), GURL(kBaseUrl));
+    fetcher->SetClockForTesting(mock_task_runner_->GetMockClock());
+    return fetcher;
+  }
+
+  void TriggerFetch(DoodleFetcher* fetcher, DoodleConfig* response) {
+    fetcher->FetchDoodle(base::BindOnce(
+        [](DoodleConfig* doodle, const DoodleConfig& config) {
+          *doodle = std::move(config);
+        },
+        response));
+  }
+
+  base::Time TimeFromNow(uint64_t milliseconds) {
+    return mock_task_runner_->GetMockClock()->Now() +
+           base::TimeDelta::FromMilliseconds(milliseconds);
+  }
+
+  void WaitForCallbacks() {
+    mock_task_runner_->FastForwardUntilNoTasksRemain();
+  }
+
+ private:
+  GURL url_;
+  net::FakeURLFetcherFactory url_fetcher_factory_;
+  scoped_refptr<base::TestMockTimeTaskRunner> mock_task_runner_;
+  base::ThreadTaskRunnerHandle mock_task_runner_handle_;
+  scoped_refptr<net::TestURLRequestContextGetter> context_getter;
+  safe_json::TestingJsonParser::ScopedFactoryOverride factory_override;
+};
+
+TEST_F(DoodleFetcherTest, ReturnsFromFetchWithoutError) {
+  RespondWithData(kSampleResponse);
+
+  EXPECT_THAT(FetchDoodle().state, Eq(DoodleState::AVAILABLE));
+}
+
+TEST_F(DoodleFetcherTest, ReturnsFrom404FetchWithError) {
+  RespondWithError();
+
+  EXPECT_THAT(FetchDoodle().state, Eq(DoodleState::DOWNLOAD_ERROR));
+}
+
+TEST_F(DoodleFetcherTest, ReturnsErrorForInvalidJson) {
+  RespondWithData("{}");
+
+  EXPECT_THAT(FetchDoodle().state, Eq(DoodleState::PARSING_ERROR));
+}
+
+TEST_F(DoodleFetcherTest, ResponseContainsValidBaseInformation) {
+  RespondWithData(kSampleResponse);
+
+  DoodleConfig response = FetchDoodle();
+
+  EXPECT_TRUE(response.search_url.is_valid());
+  EXPECT_THAT(response.search_url, Eq(AbsoluteUrl("/search?q\u003dtest")));
+  EXPECT_THAT(response.fullpage_interactive_url, Eq(GURL()));
+  EXPECT_TRUE(response.target_url.is_valid());
+  EXPECT_THAT(response.target_url,
+              Eq(AbsoluteUrl("/search?q\u003dtest\u0026sa\u003dX\u0026ved\u003d"
+                             "0ahUKEwjm9vmF8enRAhUJvBQKHX1CC54QNggB")));
+  EXPECT_THAT(response.doodle_type, Eq(DoodleType::SIMPLE));
+  EXPECT_THAT(response.alt_text, Eq("Mouseover Text"));
+
+  EXPECT_THAT(response.expiry_date, Eq(TimeFromNow(514220215000)));
+}
+
+TEST_F(DoodleFetcherTest, EmptyResponsesYieldEmptyUrlsAndNoDoodleState) {
+  RespondWithData("{\"ddljson\":{}}");
+
+  DoodleConfig response = FetchDoodle();
+
+  EXPECT_THAT(response.state, Eq(DoodleState::NO_DOODLE));
+
+  EXPECT_FALSE(response.search_url.is_valid());
+  EXPECT_THAT(response.search_url, Eq(GURL()));
+
+  EXPECT_FALSE(response.fullpage_interactive_url.is_valid());
+  EXPECT_THAT(response.fullpage_interactive_url, Eq(GURL()));
+
+  EXPECT_FALSE(response.target_url.is_valid());
+  EXPECT_THAT(response.target_url, Eq(GURL()));
+
+  EXPECT_FALSE(response.small_image.url.is_valid());
+  EXPECT_THAT(response.small_image.url, Eq(GURL()));
+  EXPECT_FALSE(response.medium_image.url.is_valid());
+  EXPECT_THAT(response.medium_image.url, Eq(GURL()));
+  EXPECT_FALSE(response.hires_image.url.is_valid());
+  EXPECT_THAT(response.hires_image.url, Eq(GURL()));
+  EXPECT_FALSE(response.large_image.url.is_valid());
+  EXPECT_THAT(response.large_image.url, Eq(GURL()));
+  EXPECT_FALSE(response.transparent_large_image.url.is_valid());
+  EXPECT_THAT(response.transparent_large_image.url, Eq(GURL()));
+}
+
+TEST_F(DoodleFetcherTest, ResponseContainsExactlyTheSampleImages) {
+  RespondWithData(kSampleResponse);
+
+  DoodleConfig response = FetchDoodle();
+
+  EXPECT_TRUE(response.small_image.url.is_valid());
+  EXPECT_THAT(response.small_image.url.spec(),
+              Eq(AbsoluteUrl("/logos/doodles/2015/new-years-eve-2015-5985438795"
+                             "825152.2-res.png")));
+  EXPECT_THAT(response.small_image.width, Eq(95));
+  EXPECT_THAT(response.small_image.height, Eq(41));
+  EXPECT_THAT(response.small_image.background_color, Eq(""));
+  EXPECT_FALSE(response.small_image.is_animated_gif);
+  EXPECT_FALSE(response.small_image.is_cta);
+
+  EXPECT_TRUE(response.medium_image.url.is_valid());
+  EXPECT_THAT(response.medium_image.url.spec(),
+              Eq(AbsoluteUrl("/logos/doodles/2015/new-years-eve-2015-5985438795"
+                             "825152-m.png")));
+  EXPECT_THAT(response.medium_image.width, Eq(291));
+  EXPECT_THAT(response.medium_image.height, Eq(128));
+  EXPECT_THAT(response.medium_image.background_color, Eq("#fff1b9"));
+  EXPECT_FALSE(response.medium_image.is_animated_gif);
+  EXPECT_TRUE(response.medium_image.is_cta);
+
+  EXPECT_TRUE(response.transparent_large_image.url.is_valid());
+  EXPECT_THAT(response.transparent_large_image.url.spec(),
+              Eq(AbsoluteUrl("/logos/doodles/2015/new-years-eve-2015-5985438795"
+                             "825152-thp.png")));
+  EXPECT_THAT(response.transparent_large_image.width, Eq(510));
+  EXPECT_THAT(response.transparent_large_image.height, Eq(225));
+  EXPECT_THAT(response.transparent_large_image.background_color, Eq(""));
+  EXPECT_FALSE(response.transparent_large_image.is_animated_gif);
+  EXPECT_FALSE(response.transparent_large_image.is_cta);
+
+  EXPECT_TRUE(response.large_image.url.is_valid());
+  EXPECT_THAT(response.large_image.url.spec(),
+              Eq(AbsoluteUrl("/logos/doodles/2015/new-years-eve-2015-5985438795"
+                             "825152-hp.gif")));
+  EXPECT_THAT(response.large_image.width, Eq(489));
+  EXPECT_THAT(response.large_image.height, Eq(225));
+  EXPECT_THAT(response.large_image.background_color, Eq("#ffffff"));
+  EXPECT_TRUE(response.large_image.is_animated_gif);
+  EXPECT_FALSE(response.large_image.is_cta);
+
+  EXPECT_TRUE(response.hires_image.url.is_valid());
+  EXPECT_THAT(response.hires_image.url.spec(),
+              Eq(AbsoluteUrl("/logos/doodles/2015/new-years-eve-2015-5985438795"
+                             "825152-hp2x.gif")));
+  EXPECT_THAT(response.hires_image.width, Eq(978));
+  EXPECT_THAT(response.hires_image.height, Eq(450));
+  EXPECT_THAT(response.hires_image.background_color, Eq("#ffffff"));
+  EXPECT_TRUE(response.hires_image.is_animated_gif);
+  EXPECT_FALSE(response.hires_image.is_cta);
+}
+
+TEST_F(DoodleFetcherTest, RespondsToMultipleRequestsWithSameResponse) {
+  RespondWithData(kSampleResponse);
+
+  DoodleConfig doodle1(DoodleState::NO_DOODLE);
+  DoodleConfig doodle2(DoodleState::NO_DOODLE);
+  std::unique_ptr<DoodleFetcher> fetcher = CreateDoodleFetcher();
+
+  TriggerFetch(fetcher.get(), &doodle1);
+  TriggerFetch(fetcher.get(), &doodle2);
+
+  WaitForCallbacks();
+  // ASSERT!
+}
+
+}  // namespace doodle