| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "components/doodle/doodle_fetcher.h" |
| 6 |
| 7 #include <string> |
| 8 #include <utility> |
| 9 #include <vector> |
| 10 |
| 11 #include "base/bind.h" |
| 12 #include "base/files/file_util.h" |
| 13 #include "base/files/important_file_writer.h" |
| 14 #include "base/files/scoped_temp_dir.h" |
| 15 #include "base/json/json_reader.h" |
| 16 #include "base/json/json_writer.h" |
| 17 #include "base/memory/ptr_util.h" |
| 18 #include "base/run_loop.h" |
| 19 #include "base/test/sequenced_worker_pool_owner.h" |
| 20 #include "base/test/test_mock_time_task_runner.h" |
| 21 #include "base/threading/sequenced_task_runner_handle.h" |
| 22 #include "base/threading/thread_task_runner_handle.h" |
| 23 #include "base/values.h" |
| 24 #include "components/safe_json/testing_json_parser.h" |
| 25 #include "net/http/http_status_code.h" |
| 26 #include "net/url_request/test_url_fetcher_factory.h" |
| 27 #include "net/url_request/url_request_status.h" |
| 28 #include "net/url_request/url_request_test_util.h" |
| 29 #include "testing/gmock/include/gmock/gmock.h" |
| 30 #include "testing/gtest/include/gtest/gtest.h" |
| 31 |
| 32 using testing::Eq; |
| 33 using testing::IsEmpty; |
| 34 |
| 35 namespace doodle { |
| 36 |
| 37 namespace { |
| 38 |
| 39 const char* kSampleResponse = |
| 40 ")]}'{" |
| 41 "\"ddljson\": {" |
| 42 " \"alt_text\":\"Mouseover Text\"," |
| 43 " \"doodle_type\":\"SIMPLE\"," |
| 44 " \"gallery_url\":\"//www.google.com/doodles/burning-man-festival\"," |
| 45 " \"header_layout\":\"LEGACY\"," |
| 46 " \"hires_image\": {" |
| 47 " \"alternate_url\":\"\"," |
| 48 " \"background_color\":\"#ffffff\"," |
| 49 " \"height\":450," |
| 50 " \"image_id\":0," |
| 51 " \"image_name\":\"\"," |
| 52 " \"is_animated_gif\":true," |
| 53 " \"is_cta\":false," |
| 54 " \"offset_x\":0," |
| 55 " \"offset_y\":0," |
| 56 " \"overlay_icon_color\":\"\"," |
| 57 " \"size_type\":\"LARGE_2X\"," |
| 58 " \"slot\":8," |
| 59 " \"url\":\"/logos/doodles/2015/" |
| 60 "new-years-eve-2015-5985438795825152-hp2x.gif\"," |
| 61 " \"width\":978" |
| 62 " }," |
| 63 " \"id\":0," |
| 64 " \"intent\":\"BUILTIN\"," |
| 65 " \"large_image\": {" |
| 66 " \"alternate_url\":\"\"," |
| 67 " \"background_color\":\"#ffffff\"," |
| 68 " \"height\":225," |
| 69 " \"image_id\":0," |
| 70 " \"image_name\":\"\"," |
| 71 " \"is_animated_gif\":true," |
| 72 " \"is_cta\":false," |
| 73 " \"offset_x\":0," |
| 74 " \"offset_y\":0," |
| 75 " \"overlay_icon_color\":\"\"," |
| 76 " \"size_type\":\"LARGE\"," |
| 77 " \"slot\":1," |
| 78 " \"url\":\"/logos/doodles/2015/" |
| 79 "new-years-eve-2015-5985438795825152-hp.gif\"," |
| 80 " \"width\":489" |
| 81 " }," |
| 82 " \"medium_image\": {" |
| 83 " \"alternate_url\":\"\"," |
| 84 " \"background_color\":\"#fff1b9\"," |
| 85 " \"height\":128," |
| 86 " \"image_id\":0," |
| 87 " \"image_name\":\"\"," |
| 88 " \"is_animated_gif\":false," |
| 89 " \"is_cta\":true," |
| 90 " \"offset_x\":0," |
| 91 " \"offset_y\":0," |
| 92 " \"overlay_icon_color\":\"#ff0f15\"," |
| 93 " \"size_type\":\"LARGE_MOBILE_SRP\"," |
| 94 " \"slot\":3," |
| 95 " \"url\":\"/logos/doodles/2015/new-years-eve-2015-5985438795825152-m.pn" |
| 96 "g\"," |
| 97 " \"width\":291" |
| 98 " }," |
| 99 " \"search_url\":\"/search?q\u003dtest\"," |
| 100 " \"share_text\":\"Share Text #GoogleDoodle\nhttps://g.co/doodle/8hfqzq\"," |
| 101 " \"short_link\":\"//g.co/doodle/8hfqzq\"," |
| 102 " \"show_now_header_search_affordance\":false," |
| 103 " \"show_now_header_share_button\":true," |
| 104 " \"small_image\": {" |
| 105 " \"alternate_url\":\"\"," |
| 106 " \"background_color\":\"\"," |
| 107 " \"height\":41," |
| 108 " \"image_id\":0," |
| 109 " \"image_name\":\"\"," |
| 110 " \"is_animated_gif\":false," |
| 111 " \"is_cta\":false," |
| 112 " \"offset_x\":0," |
| 113 " \"offset_y\":0," |
| 114 " \"overlay_icon_color\":\"\"," |
| 115 " \"size_type\":\"SMALL_DESKTOP_SRP\"," |
| 116 " \"slot\":4," |
| 117 " \"url\":\"/logos/doodles/2015/" |
| 118 "new-years-eve-2015-5985438795825152.2-res.png\"," |
| 119 " \"width\":95" |
| 120 " }," |
| 121 " \"target_url\":\"/search?q\u003dtest\u0026sa\u003dX\u0026ved\u003d0ahUKE" |
| 122 "wjm9vmF8enRAhUJvBQKHX1CC54QNggB\"," |
| 123 " \"time_to_live_ms\":514220215000," |
| 124 " \"transparent_large_image\": {" |
| 125 " \"alternate_url\":\"\"," |
| 126 " \"background_color\":\"\"," |
| 127 " \"height\":225," |
| 128 " \"image_id\":0," |
| 129 " \"image_name\":\"\"," |
| 130 " \"is_animated_gif\":false," |
| 131 " \"is_cta\":false," |
| 132 " \"offset_x\":0," |
| 133 " \"offset_y\":0," |
| 134 " \"overlay_icon_color\":\"\"," |
| 135 " \"size_type\":\"LARGE\"," |
| 136 " \"slot\":2," |
| 137 " \"url\":\"/logos/doodles/2015/" |
| 138 "new-years-eve-2015-5985438795825152-thp.png\"," |
| 139 " \"width\":510" |
| 140 " }" |
| 141 "}}"; |
| 142 |
| 143 const char kBaseUrl[] = "https://www.google.com/"; |
| 144 |
| 145 std::string AbsoluteUrl(const std::string& relative_url) { |
| 146 return GURL(kBaseUrl).Resolve(relative_url).spec(); |
| 147 } |
| 148 |
| 149 } // namespace |
| 150 |
| 151 class DoodleFetcherTest : public ::testing::Test { |
| 152 public: |
| 153 DoodleFetcherTest() |
| 154 : url_(GURL(kBaseUrl).Resolve(kDoodleConfigUrl)), |
| 155 url_fetcher_factory_(nullptr), |
| 156 mock_task_runner_(new base::TestMockTimeTaskRunner()), |
| 157 mock_task_runner_handle_(mock_task_runner_), |
| 158 context_getter( |
| 159 new net::TestURLRequestContextGetter(mock_task_runner_.get())) { |
| 160 mock_task_runner_->FastForwardBy(base::TimeDelta::FromMilliseconds(80082)); |
| 161 } |
| 162 |
| 163 void RespondWithData(const std::string& data) { |
| 164 url_fetcher_factory_.SetFakeResponse(url_, data, net::HTTP_OK, |
| 165 net::URLRequestStatus::SUCCESS); |
| 166 } |
| 167 |
| 168 void RespondWithError() { |
| 169 url_fetcher_factory_.SetFakeResponse(url_, "", net::HTTP_NOT_FOUND, |
| 170 net::URLRequestStatus::FAILED); |
| 171 } |
| 172 |
| 173 DoodleConfig FetchDoodle() { |
| 174 DoodleFetcher fetcher(context_getter.get(), GURL(kBaseUrl)); |
| 175 fetcher.SetClockForTesting(mock_task_runner_->GetMockClock()); |
| 176 DoodleConfig doodle(DoodleState::NO_DOODLE); |
| 177 fetcher.FetchDoodle(base::Bind( |
| 178 [](DoodleConfig* doodle, const DoodleConfig& config) { |
| 179 *doodle = std::move(config); |
| 180 }, |
| 181 &doodle)); |
| 182 mock_task_runner_->FastForwardUntilNoTasksRemain(); |
| 183 return doodle; |
| 184 } |
| 185 |
| 186 base::Time TimeFromNow(uint64_t milliseconds) { |
| 187 return mock_task_runner_->GetMockClock()->Now() + |
| 188 base::TimeDelta::FromMilliseconds(milliseconds); |
| 189 } |
| 190 |
| 191 private: |
| 192 GURL url_; |
| 193 net::FakeURLFetcherFactory url_fetcher_factory_; |
| 194 scoped_refptr<base::TestMockTimeTaskRunner> mock_task_runner_; |
| 195 base::ThreadTaskRunnerHandle mock_task_runner_handle_; |
| 196 scoped_refptr<net::TestURLRequestContextGetter> context_getter; |
| 197 safe_json::TestingJsonParser::ScopedFactoryOverride factory_override; |
| 198 }; |
| 199 |
| 200 TEST_F(DoodleFetcherTest, ReturnsFromFetchWithoutError) { |
| 201 RespondWithData(kSampleResponse); |
| 202 |
| 203 EXPECT_THAT(FetchDoodle().state, Eq(DoodleState::AVAILABLE)); |
| 204 } |
| 205 |
| 206 TEST_F(DoodleFetcherTest, ReturnsFrom404FetchWithError) { |
| 207 RespondWithError(); |
| 208 |
| 209 EXPECT_THAT(FetchDoodle().state, Eq(DoodleState::DOWNLOAD_ERROR)); |
| 210 } |
| 211 |
| 212 TEST_F(DoodleFetcherTest, ReturnsErrorForInvalidJson) { |
| 213 RespondWithData("{}"); |
| 214 |
| 215 EXPECT_THAT(FetchDoodle().state, Eq(DoodleState::PARSING_ERROR)); |
| 216 } |
| 217 |
| 218 TEST_F(DoodleFetcherTest, ResponseContainsValidBaseInformation) { |
| 219 RespondWithData(kSampleResponse); |
| 220 |
| 221 DoodleConfig response = FetchDoodle(); |
| 222 |
| 223 EXPECT_TRUE(response.search_url.is_valid()); |
| 224 EXPECT_THAT(response.search_url, Eq(AbsoluteUrl("/search?q\u003dtest"))); |
| 225 EXPECT_THAT(response.fullpage_interactive_url, Eq(GURL())); |
| 226 EXPECT_TRUE(response.target_url.is_valid()); |
| 227 EXPECT_THAT(response.target_url, |
| 228 Eq(AbsoluteUrl("/search?q\u003dtest\u0026sa\u003dX\u0026ved\u003d" |
| 229 "0ahUKEwjm9vmF8enRAhUJvBQKHX1CC54QNggB"))); |
| 230 EXPECT_THAT(response.doodle_type, Eq(DoodleType::SIMPLE)); |
| 231 EXPECT_THAT(response.alt_text, Eq("Mouseover Text")); |
| 232 |
| 233 EXPECT_THAT(response.expiry_date, Eq(TimeFromNow(514220215000))); |
| 234 } |
| 235 |
| 236 TEST_F(DoodleFetcherTest, EmptyResponsesYieldEmptyUrlsAndNoDoodleState) { |
| 237 RespondWithData("{\"ddljson\":{}}"); |
| 238 |
| 239 DoodleConfig response = FetchDoodle(); |
| 240 |
| 241 EXPECT_THAT(response.state, Eq(DoodleState::NO_DOODLE)); |
| 242 |
| 243 EXPECT_FALSE(response.search_url.is_valid()); |
| 244 EXPECT_THAT(response.search_url, Eq(GURL())); |
| 245 |
| 246 EXPECT_FALSE(response.fullpage_interactive_url.is_valid()); |
| 247 EXPECT_THAT(response.fullpage_interactive_url, Eq(GURL())); |
| 248 |
| 249 EXPECT_FALSE(response.target_url.is_valid()); |
| 250 EXPECT_THAT(response.target_url, Eq(GURL())); |
| 251 |
| 252 EXPECT_FALSE(response.small_image.url.is_valid()); |
| 253 EXPECT_THAT(response.small_image.url, Eq(GURL())); |
| 254 EXPECT_FALSE(response.medium_image.url.is_valid()); |
| 255 EXPECT_THAT(response.medium_image.url, Eq(GURL())); |
| 256 EXPECT_FALSE(response.hires_image.url.is_valid()); |
| 257 EXPECT_THAT(response.hires_image.url, Eq(GURL())); |
| 258 EXPECT_FALSE(response.large_image.url.is_valid()); |
| 259 EXPECT_THAT(response.large_image.url, Eq(GURL())); |
| 260 EXPECT_FALSE(response.transparent_large_image.url.is_valid()); |
| 261 EXPECT_THAT(response.transparent_large_image.url, Eq(GURL())); |
| 262 } |
| 263 |
| 264 TEST_F(DoodleFetcherTest, ResponseContainsExactlyTheSampleImages) { |
| 265 RespondWithData(kSampleResponse); |
| 266 |
| 267 DoodleConfig response = FetchDoodle(); |
| 268 |
| 269 EXPECT_TRUE(response.small_image.url.is_valid()); |
| 270 EXPECT_THAT(response.small_image.url.spec(), |
| 271 Eq(AbsoluteUrl("/logos/doodles/2015/new-years-eve-2015-5985438795" |
| 272 "825152.2-res.png"))); |
| 273 EXPECT_THAT(response.small_image.width, Eq(95)); |
| 274 EXPECT_THAT(response.small_image.height, Eq(41)); |
| 275 EXPECT_THAT(response.small_image.background_color, Eq("")); |
| 276 EXPECT_FALSE(response.small_image.is_animated_gif); |
| 277 EXPECT_FALSE(response.small_image.is_cta); |
| 278 |
| 279 EXPECT_TRUE(response.medium_image.url.is_valid()); |
| 280 EXPECT_THAT(response.medium_image.url.spec(), |
| 281 Eq(AbsoluteUrl("/logos/doodles/2015/new-years-eve-2015-5985438795" |
| 282 "825152-m.png"))); |
| 283 EXPECT_THAT(response.medium_image.width, Eq(291)); |
| 284 EXPECT_THAT(response.medium_image.height, Eq(128)); |
| 285 EXPECT_THAT(response.medium_image.background_color, Eq("#fff1b9")); |
| 286 EXPECT_FALSE(response.medium_image.is_animated_gif); |
| 287 EXPECT_TRUE(response.medium_image.is_cta); |
| 288 |
| 289 EXPECT_TRUE(response.transparent_large_image.url.is_valid()); |
| 290 EXPECT_THAT(response.transparent_large_image.url.spec(), |
| 291 Eq(AbsoluteUrl("/logos/doodles/2015/new-years-eve-2015-5985438795" |
| 292 "825152-thp.png"))); |
| 293 EXPECT_THAT(response.transparent_large_image.width, Eq(510)); |
| 294 EXPECT_THAT(response.transparent_large_image.height, Eq(225)); |
| 295 EXPECT_THAT(response.transparent_large_image.background_color, Eq("")); |
| 296 EXPECT_FALSE(response.transparent_large_image.is_animated_gif); |
| 297 EXPECT_FALSE(response.transparent_large_image.is_cta); |
| 298 |
| 299 EXPECT_TRUE(response.large_image.url.is_valid()); |
| 300 EXPECT_THAT(response.large_image.url.spec(), |
| 301 Eq(AbsoluteUrl("/logos/doodles/2015/new-years-eve-2015-5985438795" |
| 302 "825152-hp.gif"))); |
| 303 EXPECT_THAT(response.large_image.width, Eq(489)); |
| 304 EXPECT_THAT(response.large_image.height, Eq(225)); |
| 305 EXPECT_THAT(response.large_image.background_color, Eq("#ffffff")); |
| 306 EXPECT_TRUE(response.large_image.is_animated_gif); |
| 307 EXPECT_FALSE(response.large_image.is_cta); |
| 308 |
| 309 EXPECT_TRUE(response.hires_image.url.is_valid()); |
| 310 EXPECT_THAT(response.hires_image.url.spec(), |
| 311 Eq(AbsoluteUrl("/logos/doodles/2015/new-years-eve-2015-5985438795" |
| 312 "825152-hp2x.gif"))); |
| 313 EXPECT_THAT(response.hires_image.width, Eq(978)); |
| 314 EXPECT_THAT(response.hires_image.height, Eq(450)); |
| 315 EXPECT_THAT(response.hires_image.background_color, Eq("#ffffff")); |
| 316 EXPECT_TRUE(response.hires_image.is_animated_gif); |
| 317 EXPECT_FALSE(response.hires_image.is_cta); |
| 318 } |
| 319 |
| 320 } // namespace doodle |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2660883002:
Introduce a Doodle Fetcher for NTP (Closed)
