blob: 867216ed075023cdfa483e7c125722c099b94e1b [file] [log] [blame]
Alex Deymoaea4c1c2015-08-19 20:24:43 -07001//
2// Copyright (C) 2012 The Android Open Source Project
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15//
rspangler@google.com49fdf182009-10-10 00:57:34 +000016
Gilad Arnoldb6c562a2013-07-01 02:19:26 -070017#include <netinet/in.h>
18#include <netinet/ip.h>
19#include <sys/socket.h>
rspangler@google.com49fdf182009-10-10 00:57:34 +000020#include <unistd.h>
Darin Petkov41c2fcf2010-08-25 13:14:48 -070021
Ben Chan02f7c1d2014-10-18 15:18:02 -070022#include <memory>
adlr@google.comc98a7ed2009-12-04 18:54:03 +000023#include <string>
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -070024#include <utility>
adlr@google.comc98a7ed2009-12-04 18:54:03 +000025#include <vector>
Darin Petkov41c2fcf2010-08-25 13:14:48 -070026
Alex Deymo706a5ab2015-11-23 17:48:30 -030027#include <base/bind.h>
Alex Deymo60ca1a72015-06-18 18:19:15 -070028#include <base/location.h>
Andrew de los Reyes45168102010-11-22 11:13:50 -080029#include <base/logging.h>
Alex Deymo535f3b72015-08-07 10:51:32 -070030#include <base/message_loop/message_loop.h>
31#include <base/strings/string_number_conversions.h>
Alex Vakulenko75039d72014-03-25 12:36:28 -070032#include <base/strings/string_util.h>
33#include <base/strings/stringprintf.h>
34#include <base/time/time.h>
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -070035#include <brillo/message_loops/base_message_loop.h>
36#include <brillo/message_loops/message_loop.h>
37#include <brillo/message_loops/message_loop_utils.h>
38#include <brillo/process.h>
39#include <brillo/streams/file_stream.h>
40#include <brillo/streams/stream.h>
Andrew de los Reyes45168102010-11-22 11:13:50 -080041#include <gtest/gtest.h>
42
Alex Deymoc1c17b42015-11-23 03:53:15 -030043#include "update_engine/common/fake_hardware.h"
Alex Deymo2c131bb2016-05-26 16:43:13 -070044#include "update_engine/common/file_fetcher.h"
Alex Deymo39910dc2015-11-09 17:04:30 -080045#include "update_engine/common/http_common.h"
Alex Deymo39910dc2015-11-09 17:04:30 -080046#include "update_engine/common/mock_http_fetcher.h"
47#include "update_engine/common/multi_range_http_fetcher.h"
48#include "update_engine/common/test_utils.h"
49#include "update_engine/common/utils.h"
Alex Deymo14c0da82016-07-20 16:45:45 -070050#include "update_engine/libcurl_http_fetcher.h"
Alex Deymof2858572016-02-25 11:20:13 -080051#include "update_engine/mock_proxy_resolver.h"
Andrew de los Reyes45168102010-11-22 11:13:50 -080052#include "update_engine/proxy_resolver.h"
rspangler@google.com49fdf182009-10-10 00:57:34 +000053
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -070054using brillo::MessageLoop;
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -070055using std::make_pair;
Andrew de los Reyes819fef22010-12-17 11:33:58 -080056using std::pair;
adlr@google.comc98a7ed2009-12-04 18:54:03 +000057using std::string;
Ben Chan02f7c1d2014-10-18 15:18:02 -070058using std::unique_ptr;
adlr@google.comc98a7ed2009-12-04 18:54:03 +000059using std::vector;
Alex Deymof2858572016-02-25 11:20:13 -080060using testing::DoAll;
61using testing::Return;
62using testing::SaveArg;
63using testing::_;
adlr@google.comc98a7ed2009-12-04 18:54:03 +000064
Gilad Arnold9bedeb52011-11-17 16:19:57 -080065namespace {
66
67const int kBigLength = 100000;
68const int kMediumLength = 1000;
Gilad Arnold34bf1ee2012-02-09 16:16:02 -080069const int kFlakyTruncateLength = 29000;
70const int kFlakySleepEvery = 3;
Gilad Arnold9bedeb52011-11-17 16:19:57 -080071const int kFlakySleepSecs = 10;
72
73} // namespace
74
rspangler@google.com49fdf182009-10-10 00:57:34 +000075namespace chromeos_update_engine {
76
Gilad Arnold9bedeb52011-11-17 16:19:57 -080077static const char *kUnusedUrl = "unused://unused";
78
Gilad Arnoldb6c562a2013-07-01 02:19:26 -070079static inline string LocalServerUrlForPath(in_port_t port,
80 const string& path) {
Alex Vakulenko75039d72014-03-25 12:36:28 -070081 string port_str = (port ? base::StringPrintf(":%hu", port) : "");
Gilad Arnoldb6c562a2013-07-01 02:19:26 -070082 return base::StringPrintf("http://127.0.0.1%s%s", port_str.c_str(),
83 path.c_str());
rspangler@google.com49fdf182009-10-10 00:57:34 +000084}
85
Gilad Arnold9bedeb52011-11-17 16:19:57 -080086//
87// Class hierarchy for HTTP server implementations.
88//
89
90class HttpServer {
rspangler@google.com49fdf182009-10-10 00:57:34 +000091 public:
Gilad Arnold9bedeb52011-11-17 16:19:57 -080092 // This makes it an abstract class (dirty but works).
93 virtual ~HttpServer() = 0;
94
Gilad Arnoldb6c562a2013-07-01 02:19:26 -070095 virtual in_port_t GetPort() const {
96 return 0;
97 }
98
rspangler@google.com49fdf182009-10-10 00:57:34 +000099 bool started_;
100};
101
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800102HttpServer::~HttpServer() {}
rspangler@google.com49fdf182009-10-10 00:57:34 +0000103
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800104
105class NullHttpServer : public HttpServer {
rspangler@google.com49fdf182009-10-10 00:57:34 +0000106 public:
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800107 NullHttpServer() {
108 started_ = true;
rspangler@google.com49fdf182009-10-10 00:57:34 +0000109 }
rspangler@google.com49fdf182009-10-10 00:57:34 +0000110};
111
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800112
113class PythonHttpServer : public HttpServer {
rspangler@google.com49fdf182009-10-10 00:57:34 +0000114 public:
Alex Deymo535f3b72015-08-07 10:51:32 -0700115 PythonHttpServer() : port_(0) {
rspangler@google.com49fdf182009-10-10 00:57:34 +0000116 started_ = false;
Gilad Arnoldb6c562a2013-07-01 02:19:26 -0700117
118 // Spawn the server process.
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -0700119 unique_ptr<brillo::Process> http_server(new brillo::ProcessImpl());
Sen Jiang260f03b2016-03-21 15:34:58 -0700120 http_server->AddArg(test_utils::GetBuildArtifactsPath("test_http_server"));
Alex Deymo535f3b72015-08-07 10:51:32 -0700121 http_server->RedirectUsingPipe(STDOUT_FILENO, false);
122
123 if (!http_server->Start()) {
124 ADD_FAILURE() << "failed to spawn http server process";
rspangler@google.com49fdf182009-10-10 00:57:34 +0000125 return;
126 }
Alex Deymo535f3b72015-08-07 10:51:32 -0700127 LOG(INFO) << "started http server with pid " << http_server->pid();
Gilad Arnoldb6c562a2013-07-01 02:19:26 -0700128
129 // Wait for server to begin accepting connections, obtain its port.
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -0700130 brillo::StreamPtr stdout = brillo::FileStream::FromFileDescriptor(
Alex Deymo535f3b72015-08-07 10:51:32 -0700131 http_server->GetPipe(STDOUT_FILENO), false /* own */, nullptr);
132 if (!stdout)
133 return;
134
135 vector<char> buf(128);
136 string line;
137 while (line.find('\n') == string::npos) {
138 size_t read;
139 if (!stdout->ReadBlocking(buf.data(), buf.size(), &read, nullptr)) {
140 ADD_FAILURE() << "error reading http server stdout";
141 return;
Gilad Arnoldb6c562a2013-07-01 02:19:26 -0700142 }
Alex Deymo535f3b72015-08-07 10:51:32 -0700143 line.append(buf.data(), read);
144 if (read == 0)
145 break;
146 }
147 // Parse the port from the output line.
148 const size_t listening_msg_prefix_len = strlen(kServerListeningMsgPrefix);
149 if (line.size() < listening_msg_prefix_len) {
150 ADD_FAILURE() << "server output too short";
Gilad Arnoldb6c562a2013-07-01 02:19:26 -0700151 return;
152 }
153
Alex Deymo535f3b72015-08-07 10:51:32 -0700154 EXPECT_EQ(kServerListeningMsgPrefix,
155 line.substr(0, listening_msg_prefix_len));
156 string port_str = line.substr(listening_msg_prefix_len);
157 port_str.resize(port_str.find('\n'));
158 EXPECT_TRUE(base::StringToUint(port_str, &port_));
159
Andrew de los Reyes3270f742010-07-15 22:28:14 -0700160 started_ = true;
Gilad Arnoldb6c562a2013-07-01 02:19:26 -0700161 LOG(INFO) << "server running, listening on port " << port_;
Alex Deymo535f3b72015-08-07 10:51:32 -0700162
163 // Any failure before this point will SIGKILL the test server if started
164 // when the |http_server| goes out of scope.
165 http_server_ = std::move(http_server);
rspangler@google.com49fdf182009-10-10 00:57:34 +0000166 }
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800167
rspangler@google.com49fdf182009-10-10 00:57:34 +0000168 ~PythonHttpServer() {
Gilad Arnoldb6c562a2013-07-01 02:19:26 -0700169 // If there's no process, do nothing.
Alex Deymo535f3b72015-08-07 10:51:32 -0700170 if (!http_server_)
rspangler@google.com49fdf182009-10-10 00:57:34 +0000171 return;
Alex Deymo535f3b72015-08-07 10:51:32 -0700172 // Wait up to 10 seconds for the process to finish. Destroying the process
173 // will kill it with a SIGKILL otherwise.
174 http_server_->Kill(SIGTERM, 10);
rspangler@google.com49fdf182009-10-10 00:57:34 +0000175 }
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800176
Alex Deymo610277e2014-11-11 21:18:11 -0800177 in_port_t GetPort() const override {
Gilad Arnoldb6c562a2013-07-01 02:19:26 -0700178 return port_;
179 }
180
181 private:
Gilad Arnoldb6c562a2013-07-01 02:19:26 -0700182 static const char* kServerListeningMsgPrefix;
183
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -0700184 unique_ptr<brillo::Process> http_server_;
Alex Deymo535f3b72015-08-07 10:51:32 -0700185 unsigned int port_;
rspangler@google.com49fdf182009-10-10 00:57:34 +0000186};
187
Gilad Arnoldb6c562a2013-07-01 02:19:26 -0700188const char* PythonHttpServer::kServerListeningMsgPrefix = "listening on port ";
189
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800190//
191// Class hierarchy for HTTP fetcher test wrappers.
192//
193
194class AnyHttpFetcherTest {
rspangler@google.com49fdf182009-10-10 00:57:34 +0000195 public:
Chris Sosa77f79e82014-06-02 18:16:24 -0700196 AnyHttpFetcherTest() {}
Alex Deymoc4acdf42014-05-28 21:07:10 -0700197 virtual ~AnyHttpFetcherTest() {}
Jay Srinivasan43488792012-06-19 00:25:31 -0700198
Alex Deymof2858572016-02-25 11:20:13 -0800199 virtual HttpFetcher* NewLargeFetcher(ProxyResolver* proxy_resolver) = 0;
200 HttpFetcher* NewLargeFetcher(size_t num_proxies) {
201 proxy_resolver_.set_num_proxies(num_proxies);
202 return NewLargeFetcher(&proxy_resolver_);
203 }
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800204 HttpFetcher* NewLargeFetcher() {
205 return NewLargeFetcher(1);
206 }
207
Alex Deymof2858572016-02-25 11:20:13 -0800208 virtual HttpFetcher* NewSmallFetcher(ProxyResolver* proxy_resolver) = 0;
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800209 HttpFetcher* NewSmallFetcher() {
Alex Deymof2858572016-02-25 11:20:13 -0800210 proxy_resolver_.set_num_proxies(1);
211 return NewSmallFetcher(&proxy_resolver_);
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800212 }
213
Gilad Arnoldb6c562a2013-07-01 02:19:26 -0700214 virtual string BigUrl(in_port_t port) const { return kUnusedUrl; }
215 virtual string SmallUrl(in_port_t port) const { return kUnusedUrl; }
216 virtual string ErrorUrl(in_port_t port) const { return kUnusedUrl; }
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800217
218 virtual bool IsMock() const = 0;
219 virtual bool IsMulti() const = 0;
Alex Deymo2c131bb2016-05-26 16:43:13 -0700220 virtual bool IsHttpSupported() const = 0;
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800221
222 virtual void IgnoreServerAborting(HttpServer* server) const {}
223
Alex Deymo60ca1a72015-06-18 18:19:15 -0700224 virtual HttpServer* CreateServer() = 0;
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800225
Alex Deymoc1c17b42015-11-23 03:53:15 -0300226 FakeHardware* fake_hardware() {
Alex Deymo706a5ab2015-11-23 17:48:30 -0300227 return &fake_hardware_;
Alex Deymoc1c17b42015-11-23 03:53:15 -0300228 }
229
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800230 protected:
231 DirectProxyResolver proxy_resolver_;
Alex Deymo706a5ab2015-11-23 17:48:30 -0300232 FakeHardware fake_hardware_;
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800233};
234
235class MockHttpFetcherTest : public AnyHttpFetcherTest {
236 public:
237 // Necessary to unhide the definition in the base class.
238 using AnyHttpFetcherTest::NewLargeFetcher;
Alex Deymof2858572016-02-25 11:20:13 -0800239 HttpFetcher* NewLargeFetcher(ProxyResolver* proxy_resolver) override {
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -0700240 brillo::Blob big_data(1000000);
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800241 return new MockHttpFetcher(
Alex Deymof2858572016-02-25 11:20:13 -0800242 big_data.data(), big_data.size(), proxy_resolver);
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800243 }
244
245 // Necessary to unhide the definition in the base class.
246 using AnyHttpFetcherTest::NewSmallFetcher;
Alex Deymof2858572016-02-25 11:20:13 -0800247 HttpFetcher* NewSmallFetcher(ProxyResolver* proxy_resolver) override {
248 return new MockHttpFetcher("x", 1, proxy_resolver);
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800249 }
250
Alex Deymo610277e2014-11-11 21:18:11 -0800251 bool IsMock() const override { return true; }
252 bool IsMulti() const override { return false; }
Alex Deymo2c131bb2016-05-26 16:43:13 -0700253 bool IsHttpSupported() const override { return true; }
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800254
Alex Deymo60ca1a72015-06-18 18:19:15 -0700255 HttpServer* CreateServer() override {
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800256 return new NullHttpServer;
257 }
258};
259
260class LibcurlHttpFetcherTest : public AnyHttpFetcherTest {
261 public:
262 // Necessary to unhide the definition in the base class.
263 using AnyHttpFetcherTest::NewLargeFetcher;
Alex Deymof2858572016-02-25 11:20:13 -0800264 HttpFetcher* NewLargeFetcher(ProxyResolver* proxy_resolver) override {
265 LibcurlHttpFetcher* ret =
266 new LibcurlHttpFetcher(proxy_resolver, &fake_hardware_);
Darin Petkovb83371f2010-08-17 09:34:49 -0700267 // Speed up test execution.
268 ret->set_idle_seconds(1);
269 ret->set_retry_seconds(1);
Alex Deymo706a5ab2015-11-23 17:48:30 -0300270 fake_hardware_.SetIsOfficialBuild(false);
rspangler@google.com49fdf182009-10-10 00:57:34 +0000271 return ret;
272 }
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800273
274 // Necessary to unhide the definition in the base class.
275 using AnyHttpFetcherTest::NewSmallFetcher;
Alex Deymof2858572016-02-25 11:20:13 -0800276 HttpFetcher* NewSmallFetcher(ProxyResolver* proxy_resolver) override {
277 return NewLargeFetcher(proxy_resolver);
rspangler@google.com49fdf182009-10-10 00:57:34 +0000278 }
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800279
Alex Deymo610277e2014-11-11 21:18:11 -0800280 string BigUrl(in_port_t port) const override {
Gilad Arnoldb6c562a2013-07-01 02:19:26 -0700281 return LocalServerUrlForPath(port,
282 base::StringPrintf("/download/%d",
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800283 kBigLength));
rspangler@google.com49fdf182009-10-10 00:57:34 +0000284 }
Alex Deymo610277e2014-11-11 21:18:11 -0800285 string SmallUrl(in_port_t port) const override {
Gilad Arnoldb6c562a2013-07-01 02:19:26 -0700286 return LocalServerUrlForPath(port, "/foo");
rspangler@google.com49fdf182009-10-10 00:57:34 +0000287 }
Alex Deymo610277e2014-11-11 21:18:11 -0800288 string ErrorUrl(in_port_t port) const override {
Gilad Arnoldb6c562a2013-07-01 02:19:26 -0700289 return LocalServerUrlForPath(port, "/error");
Gilad Arnold48085ba2011-11-16 09:36:08 -0800290 }
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800291
Alex Deymo610277e2014-11-11 21:18:11 -0800292 bool IsMock() const override { return false; }
293 bool IsMulti() const override { return false; }
Alex Deymo2c131bb2016-05-26 16:43:13 -0700294 bool IsHttpSupported() const override { return true; }
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800295
Alex Deymo610277e2014-11-11 21:18:11 -0800296 void IgnoreServerAborting(HttpServer* server) const override {
Gilad Arnoldb6c562a2013-07-01 02:19:26 -0700297 // Nothing to do.
Andrew de los Reyes08c4e272010-04-15 14:02:17 -0700298 }
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800299
Alex Deymo60ca1a72015-06-18 18:19:15 -0700300 HttpServer* CreateServer() override {
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800301 return new PythonHttpServer;
302 }
rspangler@google.com49fdf182009-10-10 00:57:34 +0000303};
304
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800305class MultiRangeHttpFetcherTest : public LibcurlHttpFetcherTest {
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700306 public:
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800307 // Necessary to unhide the definition in the base class.
308 using AnyHttpFetcherTest::NewLargeFetcher;
Alex Deymof2858572016-02-25 11:20:13 -0800309 HttpFetcher* NewLargeFetcher(ProxyResolver* proxy_resolver) override {
310 MultiRangeHttpFetcher* ret = new MultiRangeHttpFetcher(
311 new LibcurlHttpFetcher(proxy_resolver, &fake_hardware_));
Andrew de los Reyes819fef22010-12-17 11:33:58 -0800312 ret->ClearRanges();
Gilad Arnolde4ad2502011-12-29 17:08:54 -0800313 ret->AddRange(0);
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700314 // Speed up test execution.
315 ret->set_idle_seconds(1);
316 ret->set_retry_seconds(1);
Alex Deymo706a5ab2015-11-23 17:48:30 -0300317 fake_hardware_.SetIsOfficialBuild(false);
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700318 return ret;
319 }
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800320
321 // Necessary to unhide the definition in the base class.
322 using AnyHttpFetcherTest::NewSmallFetcher;
Alex Deymof2858572016-02-25 11:20:13 -0800323 HttpFetcher* NewSmallFetcher(ProxyResolver* proxy_resolver) override {
324 return NewLargeFetcher(proxy_resolver);
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800325 }
326
Alex Deymo610277e2014-11-11 21:18:11 -0800327 bool IsMulti() const override { return true; }
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700328};
329
Alex Deymo2c131bb2016-05-26 16:43:13 -0700330class FileFetcherTest : public AnyHttpFetcherTest {
331 public:
332 // Necessary to unhide the definition in the base class.
333 using AnyHttpFetcherTest::NewLargeFetcher;
334 HttpFetcher* NewLargeFetcher(ProxyResolver* /* proxy_resolver */) override {
335 return new FileFetcher();
336 }
337
338 // Necessary to unhide the definition in the base class.
339 using AnyHttpFetcherTest::NewSmallFetcher;
340 HttpFetcher* NewSmallFetcher(ProxyResolver* proxy_resolver) override {
341 return NewLargeFetcher(proxy_resolver);
342 }
343
344 string BigUrl(in_port_t port) const override {
345 return "file://" + temp_file_.path();
346 }
347 string SmallUrl(in_port_t port) const override {
348 test_utils::WriteFileString(temp_file_.path(), "small contents");
349 return "file://" + temp_file_.path();
350 }
351 string ErrorUrl(in_port_t port) const override {
352 return "file:///path/to/non-existing-file";
353 }
354
355 bool IsMock() const override { return false; }
356 bool IsMulti() const override { return false; }
357 bool IsHttpSupported() const override { return false; }
358
359 void IgnoreServerAborting(HttpServer* server) const override {}
360
361 HttpServer* CreateServer() override { return new NullHttpServer; }
362
363 private:
364 test_utils::ScopedTempFile temp_file_{"ue_file_fetcher.XXXXXX"};
365};
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800366
367//
368// Infrastructure for type tests of HTTP fetcher.
369// See: http://code.google.com/p/googletest/wiki/AdvancedGuide#Typed_Tests
370//
371
372// Fixture class template. We use an explicit constraint to guarantee that it
373// can only be instantiated with an AnyHttpFetcherTest type, see:
374// http://www2.research.att.com/~bs/bs_faq2.html#constraints
375template <typename T>
376class HttpFetcherTest : public ::testing::Test {
377 public:
Alex Deymo535f3b72015-08-07 10:51:32 -0700378 base::MessageLoopForIO base_loop_;
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -0700379 brillo::BaseMessageLoop loop_{&base_loop_};
Alex Deymo60ca1a72015-06-18 18:19:15 -0700380
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800381 T test_;
382
Alex Deymo60ca1a72015-06-18 18:19:15 -0700383 protected:
384 HttpFetcherTest() {
385 loop_.SetAsCurrent();
386 }
387
388 void TearDown() override {
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -0700389 EXPECT_EQ(0, brillo::MessageLoopRunMaxIterations(&loop_, 1));
Alex Deymo60ca1a72015-06-18 18:19:15 -0700390 }
391
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800392 private:
Alex Deymo60ca1a72015-06-18 18:19:15 -0700393 static void TypeConstraint(T* a) {
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800394 AnyHttpFetcherTest *b = a;
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700395 if (b == 0) // Silence compiler warning of unused variable.
Yunlian Jiang2dac5762013-04-12 09:53:09 -0700396 *b = a;
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800397 }
398};
399
400// Test case types list.
401typedef ::testing::Types<LibcurlHttpFetcherTest,
402 MockHttpFetcherTest,
Alex Deymo2c131bb2016-05-26 16:43:13 -0700403 MultiRangeHttpFetcherTest,
404 FileFetcherTest>
405 HttpFetcherTestTypes;
rspangler@google.com49fdf182009-10-10 00:57:34 +0000406TYPED_TEST_CASE(HttpFetcherTest, HttpFetcherTestTypes);
407
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800408
rspangler@google.com49fdf182009-10-10 00:57:34 +0000409namespace {
410class HttpFetcherTestDelegate : public HttpFetcherDelegate {
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000411 public:
Alex Deymofdd6dec2016-03-03 22:35:43 -0800412 HttpFetcherTestDelegate() = default;
Gilad Arnold48085ba2011-11-16 09:36:08 -0800413
Alex Deymo610277e2014-11-11 21:18:11 -0800414 void ReceivedBytes(HttpFetcher* /* fetcher */,
Alex Deymofdd6dec2016-03-03 22:35:43 -0800415 const void* bytes,
416 size_t length) override {
417 data.append(reinterpret_cast<const char*>(bytes), length);
Gilad Arnold48085ba2011-11-16 09:36:08 -0800418 // Update counters
419 times_received_bytes_called_++;
rspangler@google.com49fdf182009-10-10 00:57:34 +0000420 }
Gilad Arnold48085ba2011-11-16 09:36:08 -0800421
Alex Deymo610277e2014-11-11 21:18:11 -0800422 void TransferComplete(HttpFetcher* fetcher, bool successful) override {
Gilad Arnold48085ba2011-11-16 09:36:08 -0800423 if (is_expect_error_)
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800424 EXPECT_EQ(kHttpResponseNotFound, fetcher->http_response_code());
Gilad Arnold48085ba2011-11-16 09:36:08 -0800425 else
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800426 EXPECT_EQ(kHttpResponseOk, fetcher->http_response_code());
Alex Deymo60ca1a72015-06-18 18:19:15 -0700427 MessageLoop::current()->BreakLoop();
Gilad Arnold48085ba2011-11-16 09:36:08 -0800428
429 // Update counter
430 times_transfer_complete_called_++;
rspangler@google.com49fdf182009-10-10 00:57:34 +0000431 }
Gilad Arnold48085ba2011-11-16 09:36:08 -0800432
Alex Deymo610277e2014-11-11 21:18:11 -0800433 void TransferTerminated(HttpFetcher* fetcher) override {
Gilad Arnold48085ba2011-11-16 09:36:08 -0800434 times_transfer_terminated_called_++;
Alex Deymo2c131bb2016-05-26 16:43:13 -0700435 MessageLoop::current()->BreakLoop();
Darin Petkov9ce452b2010-11-17 14:33:28 -0800436 }
Gilad Arnold48085ba2011-11-16 09:36:08 -0800437
Gilad Arnold48085ba2011-11-16 09:36:08 -0800438 // Are we expecting an error response? (default: no)
Alex Deymofdd6dec2016-03-03 22:35:43 -0800439 bool is_expect_error_{false};
Gilad Arnold48085ba2011-11-16 09:36:08 -0800440
441 // Counters for callback invocations.
Alex Deymofdd6dec2016-03-03 22:35:43 -0800442 int times_transfer_complete_called_{0};
443 int times_transfer_terminated_called_{0};
444 int times_received_bytes_called_{0};
445
446 // The received data bytes.
447 string data;
rspangler@google.com49fdf182009-10-10 00:57:34 +0000448};
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000449
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000450
Alex Deymo60ca1a72015-06-18 18:19:15 -0700451void StartTransfer(HttpFetcher* http_fetcher, const string& url) {
452 http_fetcher->BeginTransfer(url);
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000453}
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700454} // namespace
rspangler@google.com49fdf182009-10-10 00:57:34 +0000455
456TYPED_TEST(HttpFetcherTest, SimpleTest) {
Alex Deymo60ca1a72015-06-18 18:19:15 -0700457 HttpFetcherTestDelegate delegate;
458 unique_ptr<HttpFetcher> fetcher(this->test_.NewSmallFetcher());
459 fetcher->set_delegate(&delegate);
rspangler@google.com49fdf182009-10-10 00:57:34 +0000460
Alex Deymo60ca1a72015-06-18 18:19:15 -0700461 unique_ptr<HttpServer> server(this->test_.CreateServer());
462 ASSERT_TRUE(server->started_);
rspangler@google.com49fdf182009-10-10 00:57:34 +0000463
Alex Deymo60ca1a72015-06-18 18:19:15 -0700464 this->loop_.PostTask(FROM_HERE, base::Bind(
465 StartTransfer,
466 fetcher.get(),
467 this->test_.SmallUrl(server->GetPort())));
468 this->loop_.Run();
Alex Deymo71f67622017-02-03 21:30:24 -0800469 EXPECT_EQ(0, delegate.times_transfer_terminated_called_);
rspangler@google.com49fdf182009-10-10 00:57:34 +0000470}
471
Andrew de los Reyes3270f742010-07-15 22:28:14 -0700472TYPED_TEST(HttpFetcherTest, SimpleBigTest) {
Alex Deymo60ca1a72015-06-18 18:19:15 -0700473 HttpFetcherTestDelegate delegate;
474 unique_ptr<HttpFetcher> fetcher(this->test_.NewLargeFetcher());
475 fetcher->set_delegate(&delegate);
Andrew de los Reyes3270f742010-07-15 22:28:14 -0700476
Alex Deymo60ca1a72015-06-18 18:19:15 -0700477 unique_ptr<HttpServer> server(this->test_.CreateServer());
478 ASSERT_TRUE(server->started_);
Andrew de los Reyes3270f742010-07-15 22:28:14 -0700479
Alex Deymo60ca1a72015-06-18 18:19:15 -0700480 this->loop_.PostTask(FROM_HERE, base::Bind(
481 StartTransfer,
482 fetcher.get(),
483 this->test_.BigUrl(server->GetPort())));
484 this->loop_.Run();
Alex Deymo71f67622017-02-03 21:30:24 -0800485 EXPECT_EQ(0, delegate.times_transfer_terminated_called_);
Andrew de los Reyes3270f742010-07-15 22:28:14 -0700486}
487
Gilad Arnold48085ba2011-11-16 09:36:08 -0800488// Issue #9648: when server returns an error HTTP response, the fetcher needs to
489// terminate transfer prematurely, rather than try to process the error payload.
490TYPED_TEST(HttpFetcherTest, ErrorTest) {
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800491 if (this->test_.IsMock() || this->test_.IsMulti())
Gilad Arnold48085ba2011-11-16 09:36:08 -0800492 return;
Alex Deymo60ca1a72015-06-18 18:19:15 -0700493 HttpFetcherTestDelegate delegate;
Gilad Arnold48085ba2011-11-16 09:36:08 -0800494
Alex Deymo60ca1a72015-06-18 18:19:15 -0700495 // Delegate should expect an error response.
496 delegate.is_expect_error_ = true;
Gilad Arnold48085ba2011-11-16 09:36:08 -0800497
Alex Deymo60ca1a72015-06-18 18:19:15 -0700498 unique_ptr<HttpFetcher> fetcher(this->test_.NewSmallFetcher());
499 fetcher->set_delegate(&delegate);
Gilad Arnold48085ba2011-11-16 09:36:08 -0800500
Alex Deymo60ca1a72015-06-18 18:19:15 -0700501 unique_ptr<HttpServer> server(this->test_.CreateServer());
502 ASSERT_TRUE(server->started_);
Gilad Arnold48085ba2011-11-16 09:36:08 -0800503
Alex Deymo60ca1a72015-06-18 18:19:15 -0700504 this->loop_.PostTask(FROM_HERE, base::Bind(
505 StartTransfer,
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800506 fetcher.get(),
Alex Deymo60ca1a72015-06-18 18:19:15 -0700507 this->test_.ErrorUrl(server->GetPort())));
508 this->loop_.Run();
Gilad Arnold48085ba2011-11-16 09:36:08 -0800509
Alex Deymo60ca1a72015-06-18 18:19:15 -0700510 // Make sure that no bytes were received.
Alex Deymo71f67622017-02-03 21:30:24 -0800511 EXPECT_EQ(0, delegate.times_received_bytes_called_);
512 EXPECT_EQ(0U, fetcher->GetBytesDownloaded());
Gilad Arnold48085ba2011-11-16 09:36:08 -0800513
Alex Deymo60ca1a72015-06-18 18:19:15 -0700514 // Make sure that transfer completion was signaled once, and no termination
515 // was signaled.
Alex Deymo71f67622017-02-03 21:30:24 -0800516 EXPECT_EQ(1, delegate.times_transfer_complete_called_);
517 EXPECT_EQ(0, delegate.times_transfer_terminated_called_);
Gilad Arnold48085ba2011-11-16 09:36:08 -0800518}
519
Alex Deymofdd6dec2016-03-03 22:35:43 -0800520TYPED_TEST(HttpFetcherTest, ExtraHeadersInRequestTest) {
Alex Deymo2c131bb2016-05-26 16:43:13 -0700521 if (this->test_.IsMock() || !this->test_.IsHttpSupported())
Alex Deymofdd6dec2016-03-03 22:35:43 -0800522 return;
523
524 HttpFetcherTestDelegate delegate;
525 unique_ptr<HttpFetcher> fetcher(this->test_.NewSmallFetcher());
526 fetcher->set_delegate(&delegate);
527 fetcher->SetHeader("User-Agent", "MyTest");
528 fetcher->SetHeader("user-agent", "Override that header");
529 fetcher->SetHeader("Authorization", "Basic user:passwd");
530
531 // Invalid headers.
532 fetcher->SetHeader("X-Foo", "Invalid\nHeader\nIgnored");
533 fetcher->SetHeader("X-Bar: ", "I do not know how to parse");
534
535 // Hide Accept header normally added by default.
536 fetcher->SetHeader("Accept", "");
537
538 PythonHttpServer server;
539 int port = server.GetPort();
540 ASSERT_TRUE(server.started_);
541
Alex Deymo2c131bb2016-05-26 16:43:13 -0700542 this->loop_.PostTask(
543 FROM_HERE,
544 base::Bind(StartTransfer,
545 fetcher.get(),
546 LocalServerUrlForPath(port, "/echo-headers")));
Alex Deymofdd6dec2016-03-03 22:35:43 -0800547 this->loop_.Run();
548
549 EXPECT_NE(string::npos,
550 delegate.data.find("user-agent: Override that header\r\n"));
551 EXPECT_NE(string::npos,
552 delegate.data.find("Authorization: Basic user:passwd\r\n"));
553
554 EXPECT_EQ(string::npos, delegate.data.find("\nAccept:"));
555 EXPECT_EQ(string::npos, delegate.data.find("X-Foo: Invalid"));
556 EXPECT_EQ(string::npos, delegate.data.find("X-Bar: I do not"));
557}
558
rspangler@google.com49fdf182009-10-10 00:57:34 +0000559namespace {
560class PausingHttpFetcherTestDelegate : public HttpFetcherDelegate {
561 public:
Alex Deymo610277e2014-11-11 21:18:11 -0800562 void ReceivedBytes(HttpFetcher* fetcher,
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -0800563 const void* /* bytes */, size_t /* length */) override {
rspangler@google.com49fdf182009-10-10 00:57:34 +0000564 CHECK(!paused_);
565 paused_ = true;
566 fetcher->Pause();
rspangler@google.com49fdf182009-10-10 00:57:34 +0000567 }
Alex Deymo610277e2014-11-11 21:18:11 -0800568 void TransferComplete(HttpFetcher* fetcher, bool successful) override {
Alex Deymo60ca1a72015-06-18 18:19:15 -0700569 MessageLoop::current()->BreakLoop();
rspangler@google.com49fdf182009-10-10 00:57:34 +0000570 }
Alex Deymo610277e2014-11-11 21:18:11 -0800571 void TransferTerminated(HttpFetcher* fetcher) override {
Darin Petkov9ce452b2010-11-17 14:33:28 -0800572 ADD_FAILURE();
573 }
rspangler@google.com49fdf182009-10-10 00:57:34 +0000574 void Unpause() {
575 CHECK(paused_);
576 paused_ = false;
577 fetcher_->Unpause();
rspangler@google.com49fdf182009-10-10 00:57:34 +0000578 }
579 bool paused_;
580 HttpFetcher* fetcher_;
rspangler@google.com49fdf182009-10-10 00:57:34 +0000581};
582
Alex Deymo60ca1a72015-06-18 18:19:15 -0700583void UnpausingTimeoutCallback(PausingHttpFetcherTestDelegate* delegate,
584 MessageLoop::TaskId* my_id) {
rspangler@google.com49fdf182009-10-10 00:57:34 +0000585 if (delegate->paused_)
586 delegate->Unpause();
Alex Deymo60ca1a72015-06-18 18:19:15 -0700587 // Update the task id with the new scheduled callback.
588 *my_id = MessageLoop::current()->PostDelayedTask(
589 FROM_HERE,
590 base::Bind(&UnpausingTimeoutCallback, delegate, my_id),
591 base::TimeDelta::FromMilliseconds(200));
rspangler@google.com49fdf182009-10-10 00:57:34 +0000592}
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700593} // namespace
rspangler@google.com49fdf182009-10-10 00:57:34 +0000594
595TYPED_TEST(HttpFetcherTest, PauseTest) {
Alex Deymof2858572016-02-25 11:20:13 -0800596 PausingHttpFetcherTestDelegate delegate;
597 unique_ptr<HttpFetcher> fetcher(this->test_.NewLargeFetcher());
598 delegate.paused_ = false;
599 delegate.fetcher_ = fetcher.get();
600 fetcher->set_delegate(&delegate);
rspangler@google.com49fdf182009-10-10 00:57:34 +0000601
Alex Deymof2858572016-02-25 11:20:13 -0800602 unique_ptr<HttpServer> server(this->test_.CreateServer());
603 ASSERT_TRUE(server->started_);
Andrew de los Reyesf3ed8e72011-02-16 10:35:46 -0800604
Alex Deymof2858572016-02-25 11:20:13 -0800605 MessageLoop::TaskId callback_id;
606 callback_id = this->loop_.PostDelayedTask(
607 FROM_HERE,
608 base::Bind(&UnpausingTimeoutCallback, &delegate, &callback_id),
609 base::TimeDelta::FromMilliseconds(200));
610 fetcher->BeginTransfer(this->test_.BigUrl(server->GetPort()));
rspangler@google.com49fdf182009-10-10 00:57:34 +0000611
Alex Deymof2858572016-02-25 11:20:13 -0800612 this->loop_.Run();
613 EXPECT_TRUE(this->loop_.CancelTask(callback_id));
614}
615
616// This test will pause the fetcher while the download is not yet started
617// because it is waiting for the proxy to be resolved.
618TYPED_TEST(HttpFetcherTest, PauseWhileResolvingProxyTest) {
Alex Deymo2c131bb2016-05-26 16:43:13 -0700619 if (this->test_.IsMock() || !this->test_.IsHttpSupported())
Alex Deymof2858572016-02-25 11:20:13 -0800620 return;
621 MockProxyResolver mock_resolver;
622 unique_ptr<HttpFetcher> fetcher(this->test_.NewLargeFetcher(&mock_resolver));
623
624 // Saved arguments from the proxy call.
Alex Deymo35821942017-02-05 04:36:02 +0000625 ProxiesResolvedFn proxy_callback;
626 EXPECT_CALL(mock_resolver, GetProxiesForUrl("http://fake_url", _))
627 .WillOnce(DoAll(SaveArg<1>(&proxy_callback), Return(true)));
Alex Deymof2858572016-02-25 11:20:13 -0800628 fetcher->BeginTransfer("http://fake_url");
629 testing::Mock::VerifyAndClearExpectations(&mock_resolver);
630
631 // Pausing and unpausing while resolving the proxy should not affect anything.
632 fetcher->Pause();
633 fetcher->Unpause();
634 fetcher->Pause();
635 // Proxy resolver comes back after we paused the fetcher.
Alex Deymoc00ec562017-02-05 04:36:02 +0000636 ASSERT_FALSE(proxy_callback.is_null());
Alex Deymo35821942017-02-05 04:36:02 +0000637 proxy_callback.Run({1, kNoProxy});
rspangler@google.com49fdf182009-10-10 00:57:34 +0000638}
639
640namespace {
641class AbortingHttpFetcherTestDelegate : public HttpFetcherDelegate {
642 public:
Alex Deymo610277e2014-11-11 21:18:11 -0800643 void ReceivedBytes(HttpFetcher* fetcher,
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -0800644 const void* bytes, size_t length) override {}
Alex Deymo610277e2014-11-11 21:18:11 -0800645 void TransferComplete(HttpFetcher* fetcher, bool successful) override {
Darin Petkov9ce452b2010-11-17 14:33:28 -0800646 ADD_FAILURE(); // We should never get here
Alex Deymo60ca1a72015-06-18 18:19:15 -0700647 MessageLoop::current()->BreakLoop();
rspangler@google.com49fdf182009-10-10 00:57:34 +0000648 }
Alex Deymo610277e2014-11-11 21:18:11 -0800649 void TransferTerminated(HttpFetcher* fetcher) override {
Darin Petkov9ce452b2010-11-17 14:33:28 -0800650 EXPECT_EQ(fetcher, fetcher_.get());
651 EXPECT_FALSE(once_);
652 EXPECT_TRUE(callback_once_);
653 callback_once_ = false;
Alex Deymoc4acdf42014-05-28 21:07:10 -0700654 // The fetcher could have a callback scheduled on the ProxyResolver that
655 // can fire after this callback. We wait until the end of the test to
656 // delete the fetcher.
Andrew de los Reyes819fef22010-12-17 11:33:58 -0800657 }
rspangler@google.com49fdf182009-10-10 00:57:34 +0000658 void TerminateTransfer() {
659 CHECK(once_);
660 once_ = false;
661 fetcher_->TerminateTransfer();
662 }
663 void EndLoop() {
Alex Deymo60ca1a72015-06-18 18:19:15 -0700664 MessageLoop::current()->BreakLoop();
rspangler@google.com49fdf182009-10-10 00:57:34 +0000665 }
666 bool once_;
Darin Petkov9ce452b2010-11-17 14:33:28 -0800667 bool callback_once_;
Ben Chan02f7c1d2014-10-18 15:18:02 -0700668 unique_ptr<HttpFetcher> fetcher_;
rspangler@google.com49fdf182009-10-10 00:57:34 +0000669};
670
Alex Deymo60ca1a72015-06-18 18:19:15 -0700671void AbortingTimeoutCallback(AbortingHttpFetcherTestDelegate* delegate,
672 MessageLoop::TaskId* my_id) {
rspangler@google.com49fdf182009-10-10 00:57:34 +0000673 if (delegate->once_) {
674 delegate->TerminateTransfer();
Alex Deymo60ca1a72015-06-18 18:19:15 -0700675 *my_id = MessageLoop::current()->PostTask(
676 FROM_HERE,
677 base::Bind(AbortingTimeoutCallback, delegate, my_id));
rspangler@google.com49fdf182009-10-10 00:57:34 +0000678 } else {
679 delegate->EndLoop();
Alex Deymo60ca1a72015-06-18 18:19:15 -0700680 *my_id = MessageLoop::kTaskIdNull;
rspangler@google.com49fdf182009-10-10 00:57:34 +0000681 }
682}
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700683} // namespace
rspangler@google.com49fdf182009-10-10 00:57:34 +0000684
685TYPED_TEST(HttpFetcherTest, AbortTest) {
Alex Deymo60ca1a72015-06-18 18:19:15 -0700686 AbortingHttpFetcherTestDelegate delegate;
687 delegate.fetcher_.reset(this->test_.NewLargeFetcher());
688 delegate.once_ = true;
689 delegate.callback_once_ = true;
690 delegate.fetcher_->set_delegate(&delegate);
rspangler@google.com49fdf182009-10-10 00:57:34 +0000691
Alex Deymo60ca1a72015-06-18 18:19:15 -0700692 unique_ptr<HttpServer> server(this->test_.CreateServer());
693 this->test_.IgnoreServerAborting(server.get());
694 ASSERT_TRUE(server->started_);
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800695
Alex Deymo60ca1a72015-06-18 18:19:15 -0700696 MessageLoop::TaskId task_id = MessageLoop::kTaskIdNull;
rspangler@google.com49fdf182009-10-10 00:57:34 +0000697
Alex Deymo60ca1a72015-06-18 18:19:15 -0700698 task_id = this->loop_.PostTask(
699 FROM_HERE,
700 base::Bind(AbortingTimeoutCallback, &delegate, &task_id));
701 delegate.fetcher_->BeginTransfer(this->test_.BigUrl(server->GetPort()));
702
703 this->loop_.Run();
704 CHECK(!delegate.once_);
705 CHECK(!delegate.callback_once_);
706 this->loop_.CancelTask(task_id);
rspangler@google.com49fdf182009-10-10 00:57:34 +0000707}
708
Alex Deymo71f67622017-02-03 21:30:24 -0800709TYPED_TEST(HttpFetcherTest, TerminateTransferWhileResolvingProxyTest) {
710 if (this->test_.IsMock() || !this->test_.IsHttpSupported())
711 return;
712 MockProxyResolver mock_resolver;
713 unique_ptr<HttpFetcher> fetcher(this->test_.NewLargeFetcher(&mock_resolver));
714
715 HttpFetcherTestDelegate delegate;
716 fetcher->set_delegate(&delegate);
717
718 EXPECT_CALL(mock_resolver, GetProxiesForUrl(_, _)).WillOnce(Return(123));
719 fetcher->BeginTransfer("http://fake_url");
720 // Run the message loop until idle. This must call the MockProxyResolver with
721 // the request.
722 while (this->loop_.RunOnce(false)) {
723 }
724 testing::Mock::VerifyAndClearExpectations(&mock_resolver);
725
726 EXPECT_CALL(mock_resolver, CancelProxyRequest(123)).WillOnce(Return(true));
727
728 // Terminate the transfer right before the proxy resolution response.
729 fetcher->TerminateTransfer();
730 EXPECT_EQ(0, delegate.times_received_bytes_called_);
731 EXPECT_EQ(0, delegate.times_transfer_complete_called_);
732 EXPECT_EQ(1, delegate.times_transfer_terminated_called_);
733}
734
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000735namespace {
736class FlakyHttpFetcherTestDelegate : public HttpFetcherDelegate {
737 public:
Alex Deymo610277e2014-11-11 21:18:11 -0800738 void ReceivedBytes(HttpFetcher* fetcher,
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -0800739 const void* bytes, size_t length) override {
740 data.append(reinterpret_cast<const char*>(bytes), length);
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000741 }
Alex Deymo610277e2014-11-11 21:18:11 -0800742 void TransferComplete(HttpFetcher* fetcher, bool successful) override {
Andrew de los Reyesfb4ad7d2010-07-19 10:43:46 -0700743 EXPECT_TRUE(successful);
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800744 EXPECT_EQ(kHttpResponsePartialContent, fetcher->http_response_code());
Alex Deymo60ca1a72015-06-18 18:19:15 -0700745 MessageLoop::current()->BreakLoop();
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000746 }
Alex Deymo610277e2014-11-11 21:18:11 -0800747 void TransferTerminated(HttpFetcher* fetcher) override {
Darin Petkov9ce452b2010-11-17 14:33:28 -0800748 ADD_FAILURE();
749 }
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000750 string data;
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000751};
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700752} // namespace
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000753
754TYPED_TEST(HttpFetcherTest, FlakyTest) {
Alex Deymo2c131bb2016-05-26 16:43:13 -0700755 if (this->test_.IsMock() || !this->test_.IsHttpSupported())
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000756 return;
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000757 {
758 FlakyHttpFetcherTestDelegate delegate;
Ben Chan02f7c1d2014-10-18 15:18:02 -0700759 unique_ptr<HttpFetcher> fetcher(this->test_.NewSmallFetcher());
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000760 fetcher->set_delegate(&delegate);
761
Ben Chan02f7c1d2014-10-18 15:18:02 -0700762 unique_ptr<HttpServer> server(this->test_.CreateServer());
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800763 ASSERT_TRUE(server->started_);
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000764
Alex Deymo60ca1a72015-06-18 18:19:15 -0700765 this->loop_.PostTask(FROM_HERE, base::Bind(
766 &StartTransfer,
767 fetcher.get(),
768 LocalServerUrlForPath(server->GetPort(),
769 base::StringPrintf("/flaky/%d/%d/%d/%d",
770 kBigLength,
771 kFlakyTruncateLength,
772 kFlakySleepEvery,
773 kFlakySleepSecs))));
774 this->loop_.Run();
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000775
776 // verify the data we get back
Alex Deymo80f70ff2016-02-10 16:08:11 -0800777 ASSERT_EQ(kBigLength, static_cast<int>(delegate.data.size()));
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800778 for (int i = 0; i < kBigLength; i += 10) {
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000779 // Assert so that we don't flood the screen w/ EXPECT errors on failure.
780 ASSERT_EQ(delegate.data.substr(i, 10), "abcdefghij");
781 }
782 }
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000783}
784
Andrew de los Reyes9bbd1872010-07-16 14:52:29 -0700785namespace {
Chris Sosa0a364bb2014-06-10 18:18:24 -0700786// This delegate kills the server attached to it after receiving any bytes.
787// This can be used for testing what happens when you try to fetch data and
788// the server dies.
Andrew de los Reyes9bbd1872010-07-16 14:52:29 -0700789class FailureHttpFetcherTestDelegate : public HttpFetcherDelegate {
790 public:
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700791 explicit FailureHttpFetcherTestDelegate(PythonHttpServer* server)
Alex Deymo60ca1a72015-06-18 18:19:15 -0700792 : server_(server) {}
Jay Srinivasan135a58b2012-07-13 12:46:49 -0700793
Alex Deymo610277e2014-11-11 21:18:11 -0800794 ~FailureHttpFetcherTestDelegate() override {
Jay Srinivasan135a58b2012-07-13 12:46:49 -0700795 if (server_) {
796 LOG(INFO) << "Stopping server in destructor";
Alex Deymob20de692017-02-05 07:47:37 +0000797 server_.reset();
Jay Srinivasan135a58b2012-07-13 12:46:49 -0700798 LOG(INFO) << "server stopped";
799 }
800 }
801
Alex Deymo610277e2014-11-11 21:18:11 -0800802 void ReceivedBytes(HttpFetcher* fetcher,
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -0800803 const void* bytes, size_t length) override {
Andrew de los Reyes9bbd1872010-07-16 14:52:29 -0700804 if (server_) {
Jay Srinivasan135a58b2012-07-13 12:46:49 -0700805 LOG(INFO) << "Stopping server in ReceivedBytes";
Alex Deymob20de692017-02-05 07:47:37 +0000806 server_.reset();
Andrew de los Reyes9bbd1872010-07-16 14:52:29 -0700807 LOG(INFO) << "server stopped";
Andrew de los Reyes9bbd1872010-07-16 14:52:29 -0700808 }
809 }
Alex Deymo610277e2014-11-11 21:18:11 -0800810 void TransferComplete(HttpFetcher* fetcher, bool successful) override {
Andrew de los Reyes9bbd1872010-07-16 14:52:29 -0700811 EXPECT_FALSE(successful);
Chris Sosa0a364bb2014-06-10 18:18:24 -0700812 EXPECT_EQ(0, fetcher->http_response_code());
Alex Deymob20de692017-02-05 07:47:37 +0000813 times_transfer_complete_called_++;
Alex Deymo60ca1a72015-06-18 18:19:15 -0700814 MessageLoop::current()->BreakLoop();
Andrew de los Reyes9bbd1872010-07-16 14:52:29 -0700815 }
Alex Deymo610277e2014-11-11 21:18:11 -0800816 void TransferTerminated(HttpFetcher* fetcher) override {
Alex Deymob20de692017-02-05 07:47:37 +0000817 times_transfer_terminated_called_++;
818 MessageLoop::current()->BreakLoop();
Darin Petkov9ce452b2010-11-17 14:33:28 -0800819 }
Alex Deymob20de692017-02-05 07:47:37 +0000820 unique_ptr<PythonHttpServer> server_;
821 int times_transfer_terminated_called_{0};
822 int times_transfer_complete_called_{0};
Andrew de los Reyes9bbd1872010-07-16 14:52:29 -0700823};
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700824} // namespace
Andrew de los Reyes9bbd1872010-07-16 14:52:29 -0700825
826
827TYPED_TEST(HttpFetcherTest, FailureTest) {
Chris Sosa0a364bb2014-06-10 18:18:24 -0700828 // This test ensures that a fetcher responds correctly when a server isn't
829 // available at all.
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800830 if (this->test_.IsMock())
Andrew de los Reyes9bbd1872010-07-16 14:52:29 -0700831 return;
Alex Deymob20de692017-02-05 07:47:37 +0000832 FailureHttpFetcherTestDelegate delegate(nullptr);
833 unique_ptr<HttpFetcher> fetcher(this->test_.NewSmallFetcher());
834 fetcher->set_delegate(&delegate);
Andrew de los Reyes9bbd1872010-07-16 14:52:29 -0700835
Alex Deymob20de692017-02-05 07:47:37 +0000836 this->loop_.PostTask(
837 FROM_HERE,
838 base::Bind(
839 StartTransfer, fetcher.get(), "http://host_doesnt_exist99999999"));
840 this->loop_.Run();
841 EXPECT_EQ(1, delegate.times_transfer_complete_called_);
842 EXPECT_EQ(0, delegate.times_transfer_terminated_called_);
Andrew de los Reyes9bbd1872010-07-16 14:52:29 -0700843
Alex Deymob20de692017-02-05 07:47:37 +0000844 // Exiting and testing happens in the delegate
Andrew de los Reyes9bbd1872010-07-16 14:52:29 -0700845}
846
Alex Deymof123ae22015-09-24 14:59:43 -0700847TYPED_TEST(HttpFetcherTest, NoResponseTest) {
848 // This test starts a new http server but the server doesn't respond and just
849 // closes the connection.
850 if (this->test_.IsMock())
851 return;
852
853 PythonHttpServer* server = new PythonHttpServer();
854 int port = server->GetPort();
855 ASSERT_TRUE(server->started_);
856
857 // Handles destruction and claims ownership.
858 FailureHttpFetcherTestDelegate delegate(server);
859 unique_ptr<HttpFetcher> fetcher(this->test_.NewSmallFetcher());
860 fetcher->set_delegate(&delegate);
861 // The server will not reply at all, so we can limit the execution time of the
862 // test by reducing the low-speed timeout to something small. The test will
863 // finish once the TimeoutCallback() triggers (every second) and the timeout
864 // expired.
865 fetcher->set_low_speed_limit(kDownloadLowSpeedLimitBps, 1);
866
867 this->loop_.PostTask(FROM_HERE, base::Bind(
868 StartTransfer,
869 fetcher.get(),
870 LocalServerUrlForPath(port, "/hang")));
871 this->loop_.Run();
Alex Deymob20de692017-02-05 07:47:37 +0000872 EXPECT_EQ(1, delegate.times_transfer_complete_called_);
873 EXPECT_EQ(0, delegate.times_transfer_terminated_called_);
Alex Deymof123ae22015-09-24 14:59:43 -0700874
875 // Check that no other callback runs in the next two seconds. That would
876 // indicate a leaked callback.
877 bool timeout = false;
Luis Hector Chavezf1cf3482016-07-19 14:29:19 -0700878 auto callback = base::Bind([](bool* timeout) { *timeout = true; },
879 base::Unretained(&timeout));
Alex Deymof123ae22015-09-24 14:59:43 -0700880 this->loop_.PostDelayedTask(FROM_HERE, callback,
881 base::TimeDelta::FromSeconds(2));
882 EXPECT_TRUE(this->loop_.RunOnce(true));
883 EXPECT_TRUE(timeout);
884}
885
Andrew de los Reyes9bbd1872010-07-16 14:52:29 -0700886TYPED_TEST(HttpFetcherTest, ServerDiesTest) {
Chris Sosa0a364bb2014-06-10 18:18:24 -0700887 // This test starts a new http server and kills it after receiving its first
888 // set of bytes. It test whether or not our fetcher eventually gives up on
889 // retries and aborts correctly.
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800890 if (this->test_.IsMock())
Andrew de los Reyes9bbd1872010-07-16 14:52:29 -0700891 return;
Alex Deymob20de692017-02-05 07:47:37 +0000892 PythonHttpServer* server = new PythonHttpServer();
893 int port = server->GetPort();
894 ASSERT_TRUE(server->started_);
Chris Sosa0a364bb2014-06-10 18:18:24 -0700895
Alex Deymob20de692017-02-05 07:47:37 +0000896 // Handles destruction and claims ownership.
897 FailureHttpFetcherTestDelegate delegate(server);
898 unique_ptr<HttpFetcher> fetcher(this->test_.NewSmallFetcher());
899 fetcher->set_delegate(&delegate);
Andrew de los Reyes9bbd1872010-07-16 14:52:29 -0700900
Alex Deymob20de692017-02-05 07:47:37 +0000901 this->loop_.PostTask(
902 FROM_HERE,
903 base::Bind(StartTransfer,
904 fetcher.get(),
905 LocalServerUrlForPath(port,
906 base::StringPrintf("/flaky/%d/%d/%d/%d",
907 kBigLength,
908 kFlakyTruncateLength,
909 kFlakySleepEvery,
910 kFlakySleepSecs))));
911 this->loop_.Run();
912 EXPECT_EQ(1, delegate.times_transfer_complete_called_);
913 EXPECT_EQ(0, delegate.times_transfer_terminated_called_);
Andrew de los Reyes9bbd1872010-07-16 14:52:29 -0700914
Alex Deymob20de692017-02-05 07:47:37 +0000915 // Exiting and testing happens in the delegate
916}
917
918// Test that we can cancel a transfer while it is still trying to connect to the
919// server. This test kills the server after a few bytes are received.
920TYPED_TEST(HttpFetcherTest, TerminateTransferWhenServerDiedTest) {
921 if (this->test_.IsMock() || !this->test_.IsHttpSupported())
922 return;
923
924 PythonHttpServer* server = new PythonHttpServer();
925 int port = server->GetPort();
926 ASSERT_TRUE(server->started_);
927
928 // Handles destruction and claims ownership.
929 FailureHttpFetcherTestDelegate delegate(server);
930 unique_ptr<HttpFetcher> fetcher(this->test_.NewSmallFetcher());
931 fetcher->set_delegate(&delegate);
932
933 this->loop_.PostTask(
934 FROM_HERE,
935 base::Bind(StartTransfer,
936 fetcher.get(),
937 LocalServerUrlForPath(port,
938 base::StringPrintf("/flaky/%d/%d/%d/%d",
939 kBigLength,
940 kFlakyTruncateLength,
941 kFlakySleepEvery,
942 kFlakySleepSecs))));
943 // Terminating the transfer after 3 seconds gives it a chance to contact the
944 // server and enter the retry loop.
945 this->loop_.PostDelayedTask(FROM_HERE,
946 base::Bind(&HttpFetcher::TerminateTransfer,
947 base::Unretained(fetcher.get())),
948 base::TimeDelta::FromSeconds(3));
949
950 // Exiting and testing happens in the delegate.
951 this->loop_.Run();
952 EXPECT_EQ(0, delegate.times_transfer_complete_called_);
953 EXPECT_EQ(1, delegate.times_transfer_terminated_called_);
954
955 // Check that no other callback runs in the next two seconds. That would
956 // indicate a leaked callback.
957 bool timeout = false;
958 auto callback = base::Bind([](bool* timeout) { *timeout = true; },
959 base::Unretained(&timeout));
960 this->loop_.PostDelayedTask(
961 FROM_HERE, callback, base::TimeDelta::FromSeconds(2));
962 EXPECT_TRUE(this->loop_.RunOnce(true));
963 EXPECT_TRUE(timeout);
Andrew de los Reyes9bbd1872010-07-16 14:52:29 -0700964}
965
Darin Petkov41c2fcf2010-08-25 13:14:48 -0700966namespace {
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800967const HttpResponseCode kRedirectCodes[] = {
968 kHttpResponseMovedPermanently, kHttpResponseFound, kHttpResponseSeeOther,
969 kHttpResponseTempRedirect
970};
Darin Petkov41c2fcf2010-08-25 13:14:48 -0700971
972class RedirectHttpFetcherTestDelegate : public HttpFetcherDelegate {
973 public:
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700974 explicit RedirectHttpFetcherTestDelegate(bool expected_successful)
Darin Petkov41c2fcf2010-08-25 13:14:48 -0700975 : expected_successful_(expected_successful) {}
Alex Deymo610277e2014-11-11 21:18:11 -0800976 void ReceivedBytes(HttpFetcher* fetcher,
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -0800977 const void* bytes, size_t length) override {
978 data.append(reinterpret_cast<const char*>(bytes), length);
Darin Petkov41c2fcf2010-08-25 13:14:48 -0700979 }
Alex Deymo610277e2014-11-11 21:18:11 -0800980 void TransferComplete(HttpFetcher* fetcher, bool successful) override {
Darin Petkov41c2fcf2010-08-25 13:14:48 -0700981 EXPECT_EQ(expected_successful_, successful);
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700982 if (expected_successful_) {
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800983 EXPECT_EQ(kHttpResponseOk, fetcher->http_response_code());
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700984 } else {
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800985 EXPECT_GE(fetcher->http_response_code(), kHttpResponseMovedPermanently);
986 EXPECT_LE(fetcher->http_response_code(), kHttpResponseTempRedirect);
Darin Petkovcb466212010-08-26 09:40:11 -0700987 }
Alex Deymo60ca1a72015-06-18 18:19:15 -0700988 MessageLoop::current()->BreakLoop();
Darin Petkov41c2fcf2010-08-25 13:14:48 -0700989 }
Alex Deymo610277e2014-11-11 21:18:11 -0800990 void TransferTerminated(HttpFetcher* fetcher) override {
Darin Petkov9ce452b2010-11-17 14:33:28 -0800991 ADD_FAILURE();
992 }
Darin Petkov41c2fcf2010-08-25 13:14:48 -0700993 bool expected_successful_;
994 string data;
Darin Petkov41c2fcf2010-08-25 13:14:48 -0700995};
996
997// RedirectTest takes ownership of |http_fetcher|.
Gilad Arnoldb6c562a2013-07-01 02:19:26 -0700998void RedirectTest(const HttpServer* server,
999 bool expected_successful,
Darin Petkov41c2fcf2010-08-25 13:14:48 -07001000 const string& url,
1001 HttpFetcher* http_fetcher) {
Alex Deymo60ca1a72015-06-18 18:19:15 -07001002 RedirectHttpFetcherTestDelegate delegate(expected_successful);
1003 unique_ptr<HttpFetcher> fetcher(http_fetcher);
1004 fetcher->set_delegate(&delegate);
Darin Petkov41c2fcf2010-08-25 13:14:48 -07001005
Alex Deymo60ca1a72015-06-18 18:19:15 -07001006 MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
1007 StartTransfer,
1008 fetcher.get(),
1009 LocalServerUrlForPath(server->GetPort(), url)));
1010 MessageLoop::current()->Run();
1011 if (expected_successful) {
1012 // verify the data we get back
Alex Deymo80f70ff2016-02-10 16:08:11 -08001013 ASSERT_EQ(static_cast<size_t>(kMediumLength), delegate.data.size());
Alex Deymo60ca1a72015-06-18 18:19:15 -07001014 for (int i = 0; i < kMediumLength; i += 10) {
1015 // Assert so that we don't flood the screen w/ EXPECT errors on failure.
1016 ASSERT_EQ(delegate.data.substr(i, 10), "abcdefghij");
Darin Petkov41c2fcf2010-08-25 13:14:48 -07001017 }
1018 }
Darin Petkov41c2fcf2010-08-25 13:14:48 -07001019}
Alex Vakulenkod2779df2014-06-16 13:19:00 -07001020} // namespace
Darin Petkov41c2fcf2010-08-25 13:14:48 -07001021
1022TYPED_TEST(HttpFetcherTest, SimpleRedirectTest) {
Alex Deymo2c131bb2016-05-26 16:43:13 -07001023 if (this->test_.IsMock() || !this->test_.IsHttpSupported())
Darin Petkov41c2fcf2010-08-25 13:14:48 -07001024 return;
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001025
Ben Chan02f7c1d2014-10-18 15:18:02 -07001026 unique_ptr<HttpServer> server(this->test_.CreateServer());
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001027 ASSERT_TRUE(server->started_);
1028
Darin Petkov41c2fcf2010-08-25 13:14:48 -07001029 for (size_t c = 0; c < arraysize(kRedirectCodes); ++c) {
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001030 const string url = base::StringPrintf("/redirect/%d/download/%d",
1031 kRedirectCodes[c],
1032 kMediumLength);
Gilad Arnoldb6c562a2013-07-01 02:19:26 -07001033 RedirectTest(server.get(), true, url, this->test_.NewLargeFetcher());
Darin Petkov41c2fcf2010-08-25 13:14:48 -07001034 }
1035}
1036
1037TYPED_TEST(HttpFetcherTest, MaxRedirectTest) {
Alex Deymo2c131bb2016-05-26 16:43:13 -07001038 if (this->test_.IsMock() || !this->test_.IsHttpSupported())
Darin Petkov41c2fcf2010-08-25 13:14:48 -07001039 return;
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001040
Ben Chan02f7c1d2014-10-18 15:18:02 -07001041 unique_ptr<HttpServer> server(this->test_.CreateServer());
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001042 ASSERT_TRUE(server->started_);
1043
Darin Petkov41c2fcf2010-08-25 13:14:48 -07001044 string url;
David Zeuthen34135a92013-08-06 11:16:16 -07001045 for (int r = 0; r < kDownloadMaxRedirects; r++) {
Darin Petkov41c2fcf2010-08-25 13:14:48 -07001046 url += base::StringPrintf("/redirect/%d",
1047 kRedirectCodes[r % arraysize(kRedirectCodes)]);
1048 }
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001049 url += base::StringPrintf("/download/%d", kMediumLength);
Gilad Arnoldb6c562a2013-07-01 02:19:26 -07001050 RedirectTest(server.get(), true, url, this->test_.NewLargeFetcher());
Darin Petkov41c2fcf2010-08-25 13:14:48 -07001051}
1052
1053TYPED_TEST(HttpFetcherTest, BeyondMaxRedirectTest) {
Alex Deymo2c131bb2016-05-26 16:43:13 -07001054 if (this->test_.IsMock() || !this->test_.IsHttpSupported())
Darin Petkov41c2fcf2010-08-25 13:14:48 -07001055 return;
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001056
Ben Chan02f7c1d2014-10-18 15:18:02 -07001057 unique_ptr<HttpServer> server(this->test_.CreateServer());
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001058 ASSERT_TRUE(server->started_);
1059
Darin Petkov41c2fcf2010-08-25 13:14:48 -07001060 string url;
David Zeuthen34135a92013-08-06 11:16:16 -07001061 for (int r = 0; r < kDownloadMaxRedirects + 1; r++) {
Darin Petkov41c2fcf2010-08-25 13:14:48 -07001062 url += base::StringPrintf("/redirect/%d",
1063 kRedirectCodes[r % arraysize(kRedirectCodes)]);
1064 }
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001065 url += base::StringPrintf("/download/%d", kMediumLength);
Gilad Arnoldb6c562a2013-07-01 02:19:26 -07001066 RedirectTest(server.get(), false, url, this->test_.NewLargeFetcher());
Darin Petkov41c2fcf2010-08-25 13:14:48 -07001067}
1068
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001069namespace {
1070class MultiHttpFetcherTestDelegate : public HttpFetcherDelegate {
1071 public:
Alex Vakulenkod2779df2014-06-16 13:19:00 -07001072 explicit MultiHttpFetcherTestDelegate(int expected_response_code)
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001073 : expected_response_code_(expected_response_code) {}
Gilad Arnolde4ad2502011-12-29 17:08:54 -08001074
Alex Deymo610277e2014-11-11 21:18:11 -08001075 void ReceivedBytes(HttpFetcher* fetcher,
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -08001076 const void* bytes, size_t length) override {
Darin Petkov9ce452b2010-11-17 14:33:28 -08001077 EXPECT_EQ(fetcher, fetcher_.get());
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -08001078 data.append(reinterpret_cast<const char*>(bytes), length);
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001079 }
Gilad Arnolde4ad2502011-12-29 17:08:54 -08001080
Alex Deymo610277e2014-11-11 21:18:11 -08001081 void TransferComplete(HttpFetcher* fetcher, bool successful) override {
Darin Petkov9ce452b2010-11-17 14:33:28 -08001082 EXPECT_EQ(fetcher, fetcher_.get());
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001083 EXPECT_EQ(expected_response_code_ != kHttpResponseUndefined, successful);
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001084 if (expected_response_code_ != 0)
1085 EXPECT_EQ(expected_response_code_, fetcher->http_response_code());
Darin Petkov9ce452b2010-11-17 14:33:28 -08001086 // Destroy the fetcher (because we're allowed to).
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001087 fetcher_.reset(nullptr);
Alex Deymo60ca1a72015-06-18 18:19:15 -07001088 MessageLoop::current()->BreakLoop();
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001089 }
Gilad Arnolde4ad2502011-12-29 17:08:54 -08001090
Alex Deymo610277e2014-11-11 21:18:11 -08001091 void TransferTerminated(HttpFetcher* fetcher) override {
Darin Petkov9ce452b2010-11-17 14:33:28 -08001092 ADD_FAILURE();
1093 }
Gilad Arnolde4ad2502011-12-29 17:08:54 -08001094
Ben Chan02f7c1d2014-10-18 15:18:02 -07001095 unique_ptr<HttpFetcher> fetcher_;
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001096 int expected_response_code_;
1097 string data;
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001098};
1099
1100void MultiTest(HttpFetcher* fetcher_in,
Alex Deymoc1c17b42015-11-23 03:53:15 -03001101 FakeHardware* fake_hardware,
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001102 const string& url,
Ben Chanf9cb98c2014-09-21 18:31:30 -07001103 const vector<pair<off_t, off_t>>& ranges,
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001104 const string& expected_prefix,
Alex Deymo5fe0c4e2016-02-16 18:46:24 -08001105 size_t expected_size,
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001106 HttpResponseCode expected_response_code) {
Alex Deymo60ca1a72015-06-18 18:19:15 -07001107 MultiHttpFetcherTestDelegate delegate(expected_response_code);
1108 delegate.fetcher_.reset(fetcher_in);
Jay Srinivasan43488792012-06-19 00:25:31 -07001109
Alex Deymo60ca1a72015-06-18 18:19:15 -07001110 MultiRangeHttpFetcher* multi_fetcher =
Alex Deymo80f70ff2016-02-10 16:08:11 -08001111 static_cast<MultiRangeHttpFetcher*>(fetcher_in);
Alex Deymo60ca1a72015-06-18 18:19:15 -07001112 ASSERT_TRUE(multi_fetcher);
1113 multi_fetcher->ClearRanges();
1114 for (vector<pair<off_t, off_t>>::const_iterator it = ranges.begin(),
1115 e = ranges.end(); it != e; ++it) {
1116 string tmp_str = base::StringPrintf("%jd+", it->first);
1117 if (it->second > 0) {
1118 base::StringAppendF(&tmp_str, "%jd", it->second);
1119 multi_fetcher->AddRange(it->first, it->second);
1120 } else {
1121 base::StringAppendF(&tmp_str, "?");
1122 multi_fetcher->AddRange(it->first);
Andrew de los Reyes819fef22010-12-17 11:33:58 -08001123 }
Alex Deymo60ca1a72015-06-18 18:19:15 -07001124 LOG(INFO) << "added range: " << tmp_str;
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001125 }
Alex Deymoc1c17b42015-11-23 03:53:15 -03001126 fake_hardware->SetIsOfficialBuild(false);
Alex Deymo60ca1a72015-06-18 18:19:15 -07001127 multi_fetcher->set_delegate(&delegate);
1128
1129 MessageLoop::current()->PostTask(
1130 FROM_HERE,
1131 base::Bind(StartTransfer, multi_fetcher, url));
1132 MessageLoop::current()->Run();
1133
1134 EXPECT_EQ(expected_size, delegate.data.size());
1135 EXPECT_EQ(expected_prefix,
1136 string(delegate.data.data(), expected_prefix.size()));
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001137}
Alex Vakulenkod2779df2014-06-16 13:19:00 -07001138} // namespace
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001139
Darin Petkov9ce452b2010-11-17 14:33:28 -08001140TYPED_TEST(HttpFetcherTest, MultiHttpFetcherSimpleTest) {
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001141 if (!this->test_.IsMulti())
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001142 return;
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001143
Ben Chan02f7c1d2014-10-18 15:18:02 -07001144 unique_ptr<HttpServer> server(this->test_.CreateServer());
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001145 ASSERT_TRUE(server->started_);
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001146
Ben Chanf9cb98c2014-09-21 18:31:30 -07001147 vector<pair<off_t, off_t>> ranges;
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001148 ranges.push_back(make_pair(0, 25));
Gilad Arnolde4ad2502011-12-29 17:08:54 -08001149 ranges.push_back(make_pair(99, 0));
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001150 MultiTest(this->test_.NewLargeFetcher(),
Alex Deymoc1c17b42015-11-23 03:53:15 -03001151 this->test_.fake_hardware(),
Gilad Arnoldb6c562a2013-07-01 02:19:26 -07001152 this->test_.BigUrl(server->GetPort()),
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001153 ranges,
1154 "abcdefghijabcdefghijabcdejabcdefghijabcdef",
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001155 kBigLength - (99 - 25),
1156 kHttpResponsePartialContent);
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001157}
1158
1159TYPED_TEST(HttpFetcherTest, MultiHttpFetcherLengthLimitTest) {
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001160 if (!this->test_.IsMulti())
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001161 return;
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001162
Ben Chan02f7c1d2014-10-18 15:18:02 -07001163 unique_ptr<HttpServer> server(this->test_.CreateServer());
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001164 ASSERT_TRUE(server->started_);
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001165
Ben Chanf9cb98c2014-09-21 18:31:30 -07001166 vector<pair<off_t, off_t>> ranges;
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001167 ranges.push_back(make_pair(0, 24));
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001168 MultiTest(this->test_.NewLargeFetcher(),
Alex Deymoc1c17b42015-11-23 03:53:15 -03001169 this->test_.fake_hardware(),
Gilad Arnoldb6c562a2013-07-01 02:19:26 -07001170 this->test_.BigUrl(server->GetPort()),
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001171 ranges,
1172 "abcdefghijabcdefghijabcd",
1173 24,
Gilad Arnolde4ad2502011-12-29 17:08:54 -08001174 kHttpResponsePartialContent);
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001175}
1176
1177TYPED_TEST(HttpFetcherTest, MultiHttpFetcherMultiEndTest) {
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001178 if (!this->test_.IsMulti())
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001179 return;
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001180
Ben Chan02f7c1d2014-10-18 15:18:02 -07001181 unique_ptr<HttpServer> server(this->test_.CreateServer());
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001182 ASSERT_TRUE(server->started_);
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001183
Ben Chanf9cb98c2014-09-21 18:31:30 -07001184 vector<pair<off_t, off_t>> ranges;
Gilad Arnolde4ad2502011-12-29 17:08:54 -08001185 ranges.push_back(make_pair(kBigLength - 2, 0));
1186 ranges.push_back(make_pair(kBigLength - 3, 0));
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001187 MultiTest(this->test_.NewLargeFetcher(),
Alex Deymoc1c17b42015-11-23 03:53:15 -03001188 this->test_.fake_hardware(),
Gilad Arnoldb6c562a2013-07-01 02:19:26 -07001189 this->test_.BigUrl(server->GetPort()),
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001190 ranges,
1191 "ijhij",
1192 5,
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001193 kHttpResponsePartialContent);
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001194}
1195
1196TYPED_TEST(HttpFetcherTest, MultiHttpFetcherInsufficientTest) {
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001197 if (!this->test_.IsMulti())
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001198 return;
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001199
Ben Chan02f7c1d2014-10-18 15:18:02 -07001200 unique_ptr<HttpServer> server(this->test_.CreateServer());
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001201 ASSERT_TRUE(server->started_);
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001202
Ben Chanf9cb98c2014-09-21 18:31:30 -07001203 vector<pair<off_t, off_t>> ranges;
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001204 ranges.push_back(make_pair(kBigLength - 2, 4));
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001205 for (int i = 0; i < 2; ++i) {
Andrew de los Reyes819fef22010-12-17 11:33:58 -08001206 LOG(INFO) << "i = " << i;
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001207 MultiTest(this->test_.NewLargeFetcher(),
Alex Deymoc1c17b42015-11-23 03:53:15 -03001208 this->test_.fake_hardware(),
Gilad Arnoldb6c562a2013-07-01 02:19:26 -07001209 this->test_.BigUrl(server->GetPort()),
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001210 ranges,
1211 "ij",
1212 2,
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001213 kHttpResponseUndefined);
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001214 ranges.push_back(make_pair(0, 5));
1215 }
1216}
1217
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001218// Issue #18143: when a fetch of a secondary chunk out of a chain, then it
1219// should retry with other proxies listed before giving up.
1220//
1221// (1) successful recovery: The offset fetch will fail twice but succeed with
1222// the third proxy.
1223TYPED_TEST(HttpFetcherTest, MultiHttpFetcherErrorIfOffsetRecoverableTest) {
1224 if (!this->test_.IsMulti())
1225 return;
1226
Ben Chan02f7c1d2014-10-18 15:18:02 -07001227 unique_ptr<HttpServer> server(this->test_.CreateServer());
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001228 ASSERT_TRUE(server->started_);
1229
Ben Chanf9cb98c2014-09-21 18:31:30 -07001230 vector<pair<off_t, off_t>> ranges;
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001231 ranges.push_back(make_pair(0, 25));
Gilad Arnolde4ad2502011-12-29 17:08:54 -08001232 ranges.push_back(make_pair(99, 0));
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001233 MultiTest(this->test_.NewLargeFetcher(3),
Alex Deymoc1c17b42015-11-23 03:53:15 -03001234 this->test_.fake_hardware(),
Gilad Arnoldb6c562a2013-07-01 02:19:26 -07001235 LocalServerUrlForPath(server->GetPort(),
1236 base::StringPrintf("/error-if-offset/%d/2",
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001237 kBigLength)),
1238 ranges,
1239 "abcdefghijabcdefghijabcdejabcdefghijabcdef",
1240 kBigLength - (99 - 25),
1241 kHttpResponsePartialContent);
1242}
1243
1244// (2) unsuccessful recovery: The offset fetch will fail repeatedly. The
1245// fetcher will signal a (failed) completed transfer to the delegate.
1246TYPED_TEST(HttpFetcherTest, MultiHttpFetcherErrorIfOffsetUnrecoverableTest) {
1247 if (!this->test_.IsMulti())
1248 return;
1249
Ben Chan02f7c1d2014-10-18 15:18:02 -07001250 unique_ptr<HttpServer> server(this->test_.CreateServer());
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001251 ASSERT_TRUE(server->started_);
1252
Ben Chanf9cb98c2014-09-21 18:31:30 -07001253 vector<pair<off_t, off_t>> ranges;
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001254 ranges.push_back(make_pair(0, 25));
Gilad Arnolde4ad2502011-12-29 17:08:54 -08001255 ranges.push_back(make_pair(99, 0));
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001256 MultiTest(this->test_.NewLargeFetcher(2),
Alex Deymoc1c17b42015-11-23 03:53:15 -03001257 this->test_.fake_hardware(),
Gilad Arnoldb6c562a2013-07-01 02:19:26 -07001258 LocalServerUrlForPath(server->GetPort(),
1259 base::StringPrintf("/error-if-offset/%d/3",
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001260 kBigLength)),
1261 ranges,
1262 "abcdefghijabcdefghijabcde", // only received the first chunk
1263 25,
1264 kHttpResponseUndefined);
1265}
1266
Alex Deymo4ea2d922017-02-05 07:35:32 +00001267namespace {
1268// This HttpFetcherDelegate calls TerminateTransfer at a configurable point.
1269class MultiHttpFetcherTerminateTestDelegate : public HttpFetcherDelegate {
1270 public:
1271 explicit MultiHttpFetcherTerminateTestDelegate(size_t terminate_trigger_bytes)
1272 : terminate_trigger_bytes_(terminate_trigger_bytes) {}
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001273
Alex Deymo4ea2d922017-02-05 07:35:32 +00001274 void ReceivedBytes(HttpFetcher* fetcher,
1275 const void* bytes,
1276 size_t length) override {
1277 LOG(INFO) << "ReceivedBytes, " << length << " bytes.";
1278 EXPECT_EQ(fetcher, fetcher_.get());
1279 if (bytes_downloaded_ < terminate_trigger_bytes_ &&
1280 bytes_downloaded_ + length >= terminate_trigger_bytes_) {
1281 MessageLoop::current()->PostTask(
1282 FROM_HERE,
1283 base::Bind(&HttpFetcher::TerminateTransfer,
1284 base::Unretained(fetcher_.get())));
1285 }
1286 bytes_downloaded_ += length;
1287 }
1288
1289 void TransferComplete(HttpFetcher* fetcher, bool successful) override {
1290 ADD_FAILURE() << "TransferComplete called but expected a failure";
1291 // Destroy the fetcher (because we're allowed to).
1292 fetcher_.reset(nullptr);
1293 MessageLoop::current()->BreakLoop();
1294 }
1295
1296 void TransferTerminated(HttpFetcher* fetcher) override {
1297 // Destroy the fetcher (because we're allowed to).
1298 fetcher_.reset(nullptr);
1299 MessageLoop::current()->BreakLoop();
1300 }
1301
1302 unique_ptr<HttpFetcher> fetcher_;
1303 size_t bytes_downloaded_{0};
1304 size_t terminate_trigger_bytes_;
1305};
1306} // namespace
1307
1308TYPED_TEST(HttpFetcherTest, MultiHttpFetcherTerminateBetweenRangesTest) {
1309 if (!this->test_.IsMulti())
1310 return;
1311 const size_t kRangeTrigger = 1000;
1312 MultiHttpFetcherTerminateTestDelegate delegate(kRangeTrigger);
1313
1314 unique_ptr<HttpServer> server(this->test_.CreateServer());
1315 ASSERT_TRUE(server->started_);
1316
1317 MultiRangeHttpFetcher* multi_fetcher =
1318 static_cast<MultiRangeHttpFetcher*>(this->test_.NewLargeFetcher());
1319 ASSERT_TRUE(multi_fetcher);
1320 // Transfer ownership of the fetcher to the delegate.
1321 delegate.fetcher_.reset(multi_fetcher);
1322 multi_fetcher->set_delegate(&delegate);
1323
1324 multi_fetcher->ClearRanges();
1325 multi_fetcher->AddRange(45, kRangeTrigger);
1326 multi_fetcher->AddRange(2000, 100);
1327
1328 this->test_.fake_hardware()->SetIsOfficialBuild(false);
1329
1330 StartTransfer(multi_fetcher, this->test_.BigUrl(server->GetPort()));
1331 MessageLoop::current()->Run();
1332
1333 // Check that the delegate made it to the trigger point.
1334 EXPECT_EQ(kRangeTrigger, delegate.bytes_downloaded_);
1335}
Gilad Arnold9bedeb52011-11-17 16:19:57 -08001336
Andrew de los Reyesd57d1472010-10-21 13:34:08 -07001337namespace {
Darin Petkovfc7a0ce2010-10-25 10:38:37 -07001338class BlockedTransferTestDelegate : public HttpFetcherDelegate {
Andrew de los Reyesd57d1472010-10-21 13:34:08 -07001339 public:
Alex Deymo610277e2014-11-11 21:18:11 -08001340 void ReceivedBytes(HttpFetcher* fetcher,
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -08001341 const void* bytes, size_t length) override {
Andrew de los Reyesd57d1472010-10-21 13:34:08 -07001342 ADD_FAILURE();
1343 }
Alex Deymo610277e2014-11-11 21:18:11 -08001344 void TransferComplete(HttpFetcher* fetcher, bool successful) override {
Andrew de los Reyesd57d1472010-10-21 13:34:08 -07001345 EXPECT_FALSE(successful);
Alex Deymo60ca1a72015-06-18 18:19:15 -07001346 MessageLoop::current()->BreakLoop();
Andrew de los Reyesd57d1472010-10-21 13:34:08 -07001347 }
Alex Deymo610277e2014-11-11 21:18:11 -08001348 void TransferTerminated(HttpFetcher* fetcher) override {
Darin Petkov9ce452b2010-11-17 14:33:28 -08001349 ADD_FAILURE();
1350 }
Andrew de los Reyesd57d1472010-10-21 13:34:08 -07001351};
1352
Alex Deymo60ca1a72015-06-18 18:19:15 -07001353void BlockedTransferTestHelper(AnyHttpFetcherTest* fetcher_test,
1354 bool is_official_build) {
1355 if (fetcher_test->IsMock() || fetcher_test->IsMulti())
1356 return;
1357
1358 unique_ptr<HttpServer> server(fetcher_test->CreateServer());
1359 ASSERT_TRUE(server->started_);
1360
1361 BlockedTransferTestDelegate delegate;
1362 unique_ptr<HttpFetcher> fetcher(fetcher_test->NewLargeFetcher());
1363 LOG(INFO) << "is_official_build: " << is_official_build;
1364 // NewLargeFetcher creates the HttpFetcher* with a FakeSystemState.
Alex Deymoc1c17b42015-11-23 03:53:15 -03001365 fetcher_test->fake_hardware()->SetIsOfficialBuild(is_official_build);
Alex Deymo60ca1a72015-06-18 18:19:15 -07001366 fetcher->set_delegate(&delegate);
1367
1368 MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
1369 StartTransfer,
1370 fetcher.get(),
1371 LocalServerUrlForPath(server->GetPort(),
1372 fetcher_test->SmallUrl(server->GetPort()))));
1373 MessageLoop::current()->Run();
1374}
Andrew de los Reyesd57d1472010-10-21 13:34:08 -07001375} // namespace
1376
Darin Petkovfc7a0ce2010-10-25 10:38:37 -07001377TYPED_TEST(HttpFetcherTest, BlockedTransferTest) {
Alex Deymo60ca1a72015-06-18 18:19:15 -07001378 BlockedTransferTestHelper(&this->test_, false);
1379}
Andrew de los Reyesd57d1472010-10-21 13:34:08 -07001380
Alex Deymo60ca1a72015-06-18 18:19:15 -07001381TYPED_TEST(HttpFetcherTest, BlockedTransferOfficialBuildTest) {
1382 BlockedTransferTestHelper(&this->test_, true);
Andrew de los Reyesd57d1472010-10-21 13:34:08 -07001383}
1384
rspangler@google.com49fdf182009-10-10 00:57:34 +00001385} // namespace chromeos_update_engine