Mike Frysinger | 8155d08 | 2012-04-06 15:23:18 -0400 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium OS Authors. All rights reserved. |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 5 | #include <netinet/in.h> |
| 6 | #include <netinet/ip.h> |
| 7 | #include <sys/socket.h> |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 8 | #include <unistd.h> |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 9 | |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 10 | #include <string> |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 11 | #include <utility> |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 12 | #include <vector> |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 13 | |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 14 | #include <base/logging.h> |
Chris Masone | d903c3b | 2011-05-12 15:35:46 -0700 | [diff] [blame] | 15 | #include <base/memory/scoped_ptr.h> |
Alex Vakulenko | 75039d7 | 2014-03-25 12:36:28 -0700 | [diff] [blame] | 16 | #include <base/strings/string_util.h> |
| 17 | #include <base/strings/stringprintf.h> |
| 18 | #include <base/time/time.h> |
Jay Srinivasan | 4348879 | 2012-06-19 00:25:31 -0700 | [diff] [blame] | 19 | #include <chromeos/dbus/service_constants.h> |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 20 | #include <glib.h> |
| 21 | #include <gtest/gtest.h> |
| 22 | |
Gilad Arnold | 5bb4c90 | 2014-04-10 12:32:13 -0700 | [diff] [blame] | 23 | #include "update_engine/fake_system_state.h" |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 24 | #include "update_engine/http_common.h" |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 25 | #include "update_engine/libcurl_http_fetcher.h" |
| 26 | #include "update_engine/mock_http_fetcher.h" |
Andrew de los Reyes | 819fef2 | 2010-12-17 11:33:58 -0800 | [diff] [blame] | 27 | #include "update_engine/multi_range_http_fetcher.h" |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 28 | #include "update_engine/proxy_resolver.h" |
Jay Srinivasan | 08fce04 | 2012-06-07 16:31:01 -0700 | [diff] [blame] | 29 | #include "update_engine/utils.h" |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 30 | |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 31 | using std::make_pair; |
Andrew de los Reyes | 819fef2 | 2010-12-17 11:33:58 -0800 | [diff] [blame] | 32 | using std::pair; |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 33 | using std::string; |
| 34 | using std::vector; |
| 35 | |
Gilad Arnold | 8e3f126 | 2013-01-08 14:59:54 -0800 | [diff] [blame] | 36 | using base::TimeDelta; |
Jay Srinivasan | 4348879 | 2012-06-19 00:25:31 -0700 | [diff] [blame] | 37 | using testing::DoAll; |
| 38 | using testing::Return; |
Alex Deymo | c4acdf4 | 2014-05-28 21:07:10 -0700 | [diff] [blame] | 39 | using testing::SetArgumentPointee; |
| 40 | using testing::_; |
Jay Srinivasan | 4348879 | 2012-06-19 00:25:31 -0700 | [diff] [blame] | 41 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 42 | namespace { |
| 43 | |
| 44 | const int kBigLength = 100000; |
| 45 | const int kMediumLength = 1000; |
Gilad Arnold | 34bf1ee | 2012-02-09 16:16:02 -0800 | [diff] [blame] | 46 | const int kFlakyTruncateLength = 29000; |
| 47 | const int kFlakySleepEvery = 3; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 48 | const int kFlakySleepSecs = 10; |
| 49 | |
| 50 | } // namespace |
| 51 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 52 | namespace chromeos_update_engine { |
| 53 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 54 | static const char *kUnusedUrl = "unused://unused"; |
| 55 | |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 56 | static inline string LocalServerUrlForPath(in_port_t port, |
| 57 | const string& path) { |
Alex Vakulenko | 75039d7 | 2014-03-25 12:36:28 -0700 | [diff] [blame] | 58 | string port_str = (port ? base::StringPrintf(":%hu", port) : ""); |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 59 | return base::StringPrintf("http://127.0.0.1%s%s", port_str.c_str(), |
| 60 | path.c_str()); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 61 | } |
| 62 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 63 | // |
| 64 | // Class hierarchy for HTTP server implementations. |
| 65 | // |
| 66 | |
| 67 | class HttpServer { |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 68 | public: |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 69 | // This makes it an abstract class (dirty but works). |
| 70 | virtual ~HttpServer() = 0; |
| 71 | |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 72 | virtual in_port_t GetPort() const { |
| 73 | return 0; |
| 74 | } |
| 75 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 76 | bool started_; |
| 77 | }; |
| 78 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 79 | HttpServer::~HttpServer() {} |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 80 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 81 | |
| 82 | class NullHttpServer : public HttpServer { |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 83 | public: |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 84 | NullHttpServer() { |
| 85 | started_ = true; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 86 | } |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 87 | }; |
| 88 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 89 | |
| 90 | class PythonHttpServer : public HttpServer { |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 91 | public: |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 92 | PythonHttpServer() : pid_(-1), port_(0) { |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 93 | started_ = false; |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 94 | |
| 95 | // Spawn the server process. |
| 96 | gchar *argv[] = { |
| 97 | const_cast<gchar*>("./test_http_server"), |
| 98 | NULL }; |
| 99 | GError *err; |
| 100 | gint server_stdout = -1; |
| 101 | if (!g_spawn_async_with_pipes(NULL, argv, NULL, G_SPAWN_DO_NOT_REAP_CHILD, |
| 102 | NULL, NULL, &pid_, NULL, &server_stdout, NULL, |
| 103 | &err)) { |
| 104 | LOG(ERROR) << "failed to spawn http server process"; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 105 | return; |
| 106 | } |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 107 | CHECK_GT(pid_, 0); |
| 108 | CHECK_GE(server_stdout, 0); |
Jay Srinivasan | 135a58b | 2012-07-13 12:46:49 -0700 | [diff] [blame] | 109 | LOG(INFO) << "started http server with pid " << pid_; |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 110 | |
| 111 | // Wait for server to begin accepting connections, obtain its port. |
| 112 | char line[80]; |
| 113 | const size_t listening_msg_prefix_len = strlen(kServerListeningMsgPrefix); |
| 114 | CHECK_GT(sizeof(line), listening_msg_prefix_len); |
| 115 | int line_len = read(server_stdout, line, sizeof(line) - 1); |
| 116 | if (line_len <= static_cast<int>(listening_msg_prefix_len)) { |
| 117 | if (line_len < 0) { |
| 118 | LOG(ERROR) << "error reading http server stdout: " |
| 119 | << strerror(errno); |
| 120 | } else { |
| 121 | LOG(ERROR) << "server output too short"; |
| 122 | } |
| 123 | Terminate(true); |
| 124 | return; |
| 125 | } |
| 126 | |
| 127 | line[line_len] = '\0'; |
| 128 | CHECK_EQ(strstr(line, kServerListeningMsgPrefix), line); |
| 129 | const char* listening_port_str = line + listening_msg_prefix_len; |
| 130 | char* end_ptr; |
Alex Vakulenko | d2779df | 2014-06-16 13:19:00 -0700 | [diff] [blame] | 131 | long raw_port = strtol(listening_port_str, // NOLINT(runtime/int) |
| 132 | &end_ptr, 10); |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 133 | CHECK(!*end_ptr || *end_ptr == '\n'); |
| 134 | port_ = static_cast<in_port_t>(raw_port); |
| 135 | CHECK_GT(port_, 0); |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 136 | started_ = true; |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 137 | LOG(INFO) << "server running, listening on port " << port_; |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 138 | LOG(INFO) << "gdb attach now!"; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 139 | } |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 140 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 141 | ~PythonHttpServer() { |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 142 | // If there's no process, do nothing. |
| 143 | if (pid_ == -1) |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 144 | return; |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 145 | |
| 146 | // If server is responsive, request that it gracefully terminate. |
| 147 | bool do_kill = false; |
| 148 | if (started_) { |
| 149 | LOG(INFO) << "running wget to exit"; |
| 150 | if (system((string("wget -t 1 --output-document=/dev/null ") + |
| 151 | LocalServerUrlForPath(port_, "/quitquitquit")).c_str())) { |
| 152 | LOG(WARNING) << "wget failed, resorting to brute force"; |
| 153 | do_kill = true; |
| 154 | } |
Jay Srinivasan | 135a58b | 2012-07-13 12:46:49 -0700 | [diff] [blame] | 155 | } |
| 156 | |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 157 | // Server not responding or wget failed, kill the process. |
| 158 | Terminate(do_kill); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 159 | } |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 160 | |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 161 | virtual in_port_t GetPort() const { |
| 162 | return port_; |
| 163 | } |
| 164 | |
| 165 | private: |
| 166 | void Terminate(bool do_kill) { |
| 167 | ASSERT_GT(pid_, 0); |
| 168 | |
| 169 | if (do_kill) { |
| 170 | LOG(INFO) << "terminating (SIGKILL) server process with pid " << pid_; |
| 171 | kill(pid_, SIGKILL); |
| 172 | } |
| 173 | |
| 174 | LOG(INFO) << "waiting for http server with pid " << pid_ << " to terminate"; |
| 175 | int status; |
| 176 | pid_t killed_pid = waitpid(pid_, &status, 0); |
| 177 | ASSERT_EQ(killed_pid, pid_); |
| 178 | LOG(INFO) << "http server with pid " << pid_ |
| 179 | << " terminated with status " << status; |
| 180 | pid_ = -1; |
| 181 | } |
| 182 | |
| 183 | static const char* kServerListeningMsgPrefix; |
| 184 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 185 | GPid pid_; |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 186 | in_port_t port_; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 187 | }; |
| 188 | |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 189 | const char* PythonHttpServer::kServerListeningMsgPrefix = "listening on port "; |
| 190 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 191 | // |
| 192 | // Class hierarchy for HTTP fetcher test wrappers. |
| 193 | // |
| 194 | |
| 195 | class AnyHttpFetcherTest { |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 196 | public: |
Chris Sosa | 77f79e8 | 2014-06-02 18:16:24 -0700 | [diff] [blame] | 197 | AnyHttpFetcherTest() {} |
Alex Deymo | c4acdf4 | 2014-05-28 21:07:10 -0700 | [diff] [blame] | 198 | virtual ~AnyHttpFetcherTest() {} |
Jay Srinivasan | 4348879 | 2012-06-19 00:25:31 -0700 | [diff] [blame] | 199 | |
Alex Deymo | 7984bf0 | 2014-04-02 20:41:57 -0700 | [diff] [blame] | 200 | virtual HttpFetcher* NewLargeFetcher(size_t num_proxies) = 0; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 201 | HttpFetcher* NewLargeFetcher() { |
| 202 | return NewLargeFetcher(1); |
| 203 | } |
| 204 | |
| 205 | virtual HttpFetcher* NewSmallFetcher(size_t num_proxies) = 0; |
| 206 | HttpFetcher* NewSmallFetcher() { |
| 207 | return NewSmallFetcher(1); |
| 208 | } |
| 209 | |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 210 | virtual string BigUrl(in_port_t port) const { return kUnusedUrl; } |
| 211 | virtual string SmallUrl(in_port_t port) const { return kUnusedUrl; } |
| 212 | virtual string ErrorUrl(in_port_t port) const { return kUnusedUrl; } |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 213 | |
| 214 | virtual bool IsMock() const = 0; |
| 215 | virtual bool IsMulti() const = 0; |
| 216 | |
| 217 | virtual void IgnoreServerAborting(HttpServer* server) const {} |
| 218 | |
| 219 | virtual HttpServer *CreateServer() = 0; |
| 220 | |
| 221 | protected: |
| 222 | DirectProxyResolver proxy_resolver_; |
Gilad Arnold | 5bb4c90 | 2014-04-10 12:32:13 -0700 | [diff] [blame] | 223 | FakeSystemState fake_system_state_; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 224 | }; |
| 225 | |
| 226 | class MockHttpFetcherTest : public AnyHttpFetcherTest { |
| 227 | public: |
| 228 | // Necessary to unhide the definition in the base class. |
| 229 | using AnyHttpFetcherTest::NewLargeFetcher; |
| 230 | virtual HttpFetcher* NewLargeFetcher(size_t num_proxies) { |
| 231 | vector<char> big_data(1000000); |
Alex Vakulenko | d2779df | 2014-06-16 13:19:00 -0700 | [diff] [blame] | 232 | CHECK_GT(num_proxies, 0u); |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 233 | proxy_resolver_.set_num_proxies(num_proxies); |
| 234 | return new MockHttpFetcher( |
| 235 | big_data.data(), |
| 236 | big_data.size(), |
| 237 | reinterpret_cast<ProxyResolver*>(&proxy_resolver_)); |
| 238 | } |
| 239 | |
| 240 | // Necessary to unhide the definition in the base class. |
| 241 | using AnyHttpFetcherTest::NewSmallFetcher; |
| 242 | virtual HttpFetcher* NewSmallFetcher(size_t num_proxies) { |
Alex Vakulenko | d2779df | 2014-06-16 13:19:00 -0700 | [diff] [blame] | 243 | CHECK_GT(num_proxies, 0u); |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 244 | proxy_resolver_.set_num_proxies(num_proxies); |
| 245 | return new MockHttpFetcher( |
| 246 | "x", |
| 247 | 1, |
| 248 | reinterpret_cast<ProxyResolver*>(&proxy_resolver_)); |
| 249 | } |
| 250 | |
| 251 | virtual bool IsMock() const { return true; } |
| 252 | virtual bool IsMulti() const { return false; } |
| 253 | |
| 254 | virtual HttpServer *CreateServer() { |
| 255 | return new NullHttpServer; |
| 256 | } |
| 257 | }; |
| 258 | |
| 259 | class LibcurlHttpFetcherTest : public AnyHttpFetcherTest { |
| 260 | public: |
| 261 | // Necessary to unhide the definition in the base class. |
| 262 | using AnyHttpFetcherTest::NewLargeFetcher; |
| 263 | virtual HttpFetcher* NewLargeFetcher(size_t num_proxies) { |
Alex Vakulenko | d2779df | 2014-06-16 13:19:00 -0700 | [diff] [blame] | 264 | CHECK_GT(num_proxies, 0u); |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 265 | proxy_resolver_.set_num_proxies(num_proxies); |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 266 | LibcurlHttpFetcher *ret = new |
Jay Srinivasan | 08fce04 | 2012-06-07 16:31:01 -0700 | [diff] [blame] | 267 | LibcurlHttpFetcher(reinterpret_cast<ProxyResolver*>(&proxy_resolver_), |
Nam T. Nguyen | 7d623eb | 2014-05-13 16:06:28 -0700 | [diff] [blame] | 268 | &fake_system_state_); |
Darin Petkov | b83371f | 2010-08-17 09:34:49 -0700 | [diff] [blame] | 269 | // Speed up test execution. |
| 270 | ret->set_idle_seconds(1); |
| 271 | ret->set_retry_seconds(1); |
Gilad Arnold | 5bb4c90 | 2014-04-10 12:32:13 -0700 | [diff] [blame] | 272 | fake_system_state_.fake_hardware()->SetIsOfficialBuild(false); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 273 | return ret; |
| 274 | } |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 275 | |
| 276 | // Necessary to unhide the definition in the base class. |
| 277 | using AnyHttpFetcherTest::NewSmallFetcher; |
| 278 | virtual HttpFetcher* NewSmallFetcher(size_t num_proxies) { |
| 279 | return NewLargeFetcher(num_proxies); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 280 | } |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 281 | |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 282 | virtual string BigUrl(in_port_t port) const { |
| 283 | return LocalServerUrlForPath(port, |
| 284 | base::StringPrintf("/download/%d", |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 285 | kBigLength)); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 286 | } |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 287 | virtual string SmallUrl(in_port_t port) const { |
| 288 | return LocalServerUrlForPath(port, "/foo"); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 289 | } |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 290 | virtual string ErrorUrl(in_port_t port) const { |
| 291 | return LocalServerUrlForPath(port, "/error"); |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 292 | } |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 293 | |
| 294 | virtual bool IsMock() const { return false; } |
| 295 | virtual bool IsMulti() const { return false; } |
| 296 | |
| 297 | virtual void IgnoreServerAborting(HttpServer* server) const { |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 298 | // Nothing to do. |
Andrew de los Reyes | 08c4e27 | 2010-04-15 14:02:17 -0700 | [diff] [blame] | 299 | } |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 300 | |
| 301 | virtual HttpServer *CreateServer() { |
| 302 | return new PythonHttpServer; |
| 303 | } |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 304 | }; |
| 305 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 306 | class MultiRangeHttpFetcherTest : public LibcurlHttpFetcherTest { |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 307 | public: |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 308 | // Necessary to unhide the definition in the base class. |
| 309 | using AnyHttpFetcherTest::NewLargeFetcher; |
| 310 | virtual HttpFetcher* NewLargeFetcher(size_t num_proxies) { |
Alex Vakulenko | d2779df | 2014-06-16 13:19:00 -0700 | [diff] [blame] | 311 | CHECK_GT(num_proxies, 0u); |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 312 | proxy_resolver_.set_num_proxies(num_proxies); |
Andrew de los Reyes | 819fef2 | 2010-12-17 11:33:58 -0800 | [diff] [blame] | 313 | ProxyResolver* resolver = |
| 314 | reinterpret_cast<ProxyResolver*>(&proxy_resolver_); |
Gilad Arnold | 7c04e76 | 2012-05-23 10:54:02 -0700 | [diff] [blame] | 315 | MultiRangeHttpFetcher *ret = |
| 316 | new MultiRangeHttpFetcher( |
Nam T. Nguyen | 7d623eb | 2014-05-13 16:06:28 -0700 | [diff] [blame] | 317 | new LibcurlHttpFetcher(resolver, &fake_system_state_)); |
Andrew de los Reyes | 819fef2 | 2010-12-17 11:33:58 -0800 | [diff] [blame] | 318 | ret->ClearRanges(); |
Gilad Arnold | e4ad250 | 2011-12-29 17:08:54 -0800 | [diff] [blame] | 319 | ret->AddRange(0); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 320 | // Speed up test execution. |
| 321 | ret->set_idle_seconds(1); |
| 322 | ret->set_retry_seconds(1); |
Gilad Arnold | 5bb4c90 | 2014-04-10 12:32:13 -0700 | [diff] [blame] | 323 | fake_system_state_.fake_hardware()->SetIsOfficialBuild(false); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 324 | return ret; |
| 325 | } |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 326 | |
| 327 | // Necessary to unhide the definition in the base class. |
| 328 | using AnyHttpFetcherTest::NewSmallFetcher; |
| 329 | virtual HttpFetcher* NewSmallFetcher(size_t num_proxies) { |
| 330 | return NewLargeFetcher(num_proxies); |
| 331 | } |
| 332 | |
| 333 | virtual bool IsMulti() const { return true; } |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 334 | }; |
| 335 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 336 | |
| 337 | // |
| 338 | // Infrastructure for type tests of HTTP fetcher. |
| 339 | // See: http://code.google.com/p/googletest/wiki/AdvancedGuide#Typed_Tests |
| 340 | // |
| 341 | |
| 342 | // Fixture class template. We use an explicit constraint to guarantee that it |
| 343 | // can only be instantiated with an AnyHttpFetcherTest type, see: |
| 344 | // http://www2.research.att.com/~bs/bs_faq2.html#constraints |
| 345 | template <typename T> |
| 346 | class HttpFetcherTest : public ::testing::Test { |
| 347 | public: |
| 348 | T test_; |
| 349 | |
| 350 | private: |
| 351 | static void TypeConstraint(T *a) { |
| 352 | AnyHttpFetcherTest *b = a; |
Alex Vakulenko | d2779df | 2014-06-16 13:19:00 -0700 | [diff] [blame] | 353 | if (b == 0) // Silence compiler warning of unused variable. |
Yunlian Jiang | 2dac576 | 2013-04-12 09:53:09 -0700 | [diff] [blame] | 354 | *b = a; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 355 | } |
| 356 | }; |
| 357 | |
| 358 | // Test case types list. |
| 359 | typedef ::testing::Types<LibcurlHttpFetcherTest, |
| 360 | MockHttpFetcherTest, |
| 361 | MultiRangeHttpFetcherTest> HttpFetcherTestTypes; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 362 | TYPED_TEST_CASE(HttpFetcherTest, HttpFetcherTestTypes); |
| 363 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 364 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 365 | namespace { |
| 366 | class HttpFetcherTestDelegate : public HttpFetcherDelegate { |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 367 | public: |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 368 | HttpFetcherTestDelegate() : |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 369 | is_expect_error_(false), times_transfer_complete_called_(0), |
| 370 | times_transfer_terminated_called_(0), times_received_bytes_called_(0) {} |
| 371 | |
Alex Deymo | f9c5999 | 2014-04-02 21:16:59 -0700 | [diff] [blame] | 372 | virtual void ReceivedBytes(HttpFetcher* /* fetcher */, |
| 373 | const char* /* bytes */, int /* length */) { |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 374 | // Update counters |
| 375 | times_received_bytes_called_++; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 376 | } |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 377 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 378 | virtual void TransferComplete(HttpFetcher* fetcher, bool successful) { |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 379 | if (is_expect_error_) |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 380 | EXPECT_EQ(kHttpResponseNotFound, fetcher->http_response_code()); |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 381 | else |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 382 | EXPECT_EQ(kHttpResponseOk, fetcher->http_response_code()); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 383 | g_main_loop_quit(loop_); |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 384 | |
| 385 | // Update counter |
| 386 | times_transfer_complete_called_++; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 387 | } |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 388 | |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 389 | virtual void TransferTerminated(HttpFetcher* fetcher) { |
| 390 | ADD_FAILURE(); |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 391 | times_transfer_terminated_called_++; |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 392 | } |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 393 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 394 | GMainLoop* loop_; |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 395 | |
| 396 | // Are we expecting an error response? (default: no) |
| 397 | bool is_expect_error_; |
| 398 | |
| 399 | // Counters for callback invocations. |
| 400 | int times_transfer_complete_called_; |
| 401 | int times_transfer_terminated_called_; |
| 402 | int times_received_bytes_called_; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 403 | }; |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 404 | |
| 405 | struct StartTransferArgs { |
| 406 | HttpFetcher *http_fetcher; |
| 407 | string url; |
| 408 | }; |
| 409 | |
| 410 | gboolean StartTransfer(gpointer data) { |
| 411 | StartTransferArgs *args = reinterpret_cast<StartTransferArgs*>(data); |
| 412 | args->http_fetcher->BeginTransfer(args->url); |
| 413 | return FALSE; |
| 414 | } |
Alex Vakulenko | d2779df | 2014-06-16 13:19:00 -0700 | [diff] [blame] | 415 | } // namespace |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 416 | |
| 417 | TYPED_TEST(HttpFetcherTest, SimpleTest) { |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 418 | GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 419 | { |
| 420 | HttpFetcherTestDelegate delegate; |
| 421 | delegate.loop_ = loop; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 422 | scoped_ptr<HttpFetcher> fetcher(this->test_.NewSmallFetcher()); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 423 | fetcher->set_delegate(&delegate); |
| 424 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 425 | scoped_ptr<HttpServer> server(this->test_.CreateServer()); |
| 426 | ASSERT_TRUE(server->started_); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 427 | |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 428 | StartTransferArgs start_xfer_args = { |
| 429 | fetcher.get(), this->test_.SmallUrl(server->GetPort())}; |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 430 | |
| 431 | g_timeout_add(0, StartTransfer, &start_xfer_args); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 432 | g_main_loop_run(loop); |
| 433 | } |
| 434 | g_main_loop_unref(loop); |
| 435 | } |
| 436 | |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 437 | TYPED_TEST(HttpFetcherTest, SimpleBigTest) { |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 438 | GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 439 | { |
| 440 | HttpFetcherTestDelegate delegate; |
| 441 | delegate.loop_ = loop; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 442 | scoped_ptr<HttpFetcher> fetcher(this->test_.NewLargeFetcher()); |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 443 | fetcher->set_delegate(&delegate); |
| 444 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 445 | scoped_ptr<HttpServer> server(this->test_.CreateServer()); |
| 446 | ASSERT_TRUE(server->started_); |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 447 | |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 448 | StartTransferArgs start_xfer_args = { |
| 449 | fetcher.get(), this->test_.BigUrl(server->GetPort())}; |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 450 | |
| 451 | g_timeout_add(0, StartTransfer, &start_xfer_args); |
| 452 | g_main_loop_run(loop); |
| 453 | } |
| 454 | g_main_loop_unref(loop); |
| 455 | } |
| 456 | |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 457 | // Issue #9648: when server returns an error HTTP response, the fetcher needs to |
| 458 | // terminate transfer prematurely, rather than try to process the error payload. |
| 459 | TYPED_TEST(HttpFetcherTest, ErrorTest) { |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 460 | if (this->test_.IsMock() || this->test_.IsMulti()) |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 461 | return; |
| 462 | GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); |
| 463 | { |
| 464 | HttpFetcherTestDelegate delegate; |
| 465 | delegate.loop_ = loop; |
| 466 | |
| 467 | // Delegate should expect an error response. |
| 468 | delegate.is_expect_error_ = true; |
| 469 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 470 | scoped_ptr<HttpFetcher> fetcher(this->test_.NewSmallFetcher()); |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 471 | fetcher->set_delegate(&delegate); |
| 472 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 473 | scoped_ptr<HttpServer> server(this->test_.CreateServer()); |
| 474 | ASSERT_TRUE(server->started_); |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 475 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 476 | StartTransferArgs start_xfer_args = { |
| 477 | fetcher.get(), |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 478 | this->test_.ErrorUrl(server->GetPort()) |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 479 | }; |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 480 | |
| 481 | g_timeout_add(0, StartTransfer, &start_xfer_args); |
| 482 | g_main_loop_run(loop); |
| 483 | |
| 484 | // Make sure that no bytes were received. |
| 485 | CHECK_EQ(delegate.times_received_bytes_called_, 0); |
Mike Frysinger | 0f9547d | 2012-02-16 12:11:37 -0500 | [diff] [blame] | 486 | CHECK_EQ(fetcher->GetBytesDownloaded(), static_cast<size_t>(0)); |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 487 | |
| 488 | // Make sure that transfer completion was signaled once, and no termination |
| 489 | // was signaled. |
| 490 | CHECK_EQ(delegate.times_transfer_complete_called_, 1); |
| 491 | CHECK_EQ(delegate.times_transfer_terminated_called_, 0); |
| 492 | } |
| 493 | g_main_loop_unref(loop); |
| 494 | } |
| 495 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 496 | namespace { |
| 497 | class PausingHttpFetcherTestDelegate : public HttpFetcherDelegate { |
| 498 | public: |
| 499 | virtual void ReceivedBytes(HttpFetcher* fetcher, |
Alex Deymo | f9c5999 | 2014-04-02 21:16:59 -0700 | [diff] [blame] | 500 | const char* /* bytes */, int /* length */) { |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 501 | CHECK(!paused_); |
| 502 | paused_ = true; |
| 503 | fetcher->Pause(); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 504 | } |
| 505 | virtual void TransferComplete(HttpFetcher* fetcher, bool successful) { |
| 506 | g_main_loop_quit(loop_); |
| 507 | } |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 508 | virtual void TransferTerminated(HttpFetcher* fetcher) { |
| 509 | ADD_FAILURE(); |
| 510 | } |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 511 | void Unpause() { |
| 512 | CHECK(paused_); |
| 513 | paused_ = false; |
| 514 | fetcher_->Unpause(); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 515 | } |
| 516 | bool paused_; |
| 517 | HttpFetcher* fetcher_; |
| 518 | GMainLoop* loop_; |
| 519 | }; |
| 520 | |
| 521 | gboolean UnpausingTimeoutCallback(gpointer data) { |
| 522 | PausingHttpFetcherTestDelegate *delegate = |
| 523 | reinterpret_cast<PausingHttpFetcherTestDelegate*>(data); |
| 524 | if (delegate->paused_) |
| 525 | delegate->Unpause(); |
| 526 | return TRUE; |
| 527 | } |
Alex Vakulenko | d2779df | 2014-06-16 13:19:00 -0700 | [diff] [blame] | 528 | } // namespace |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 529 | |
| 530 | TYPED_TEST(HttpFetcherTest, PauseTest) { |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 531 | GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 532 | { |
| 533 | PausingHttpFetcherTestDelegate delegate; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 534 | scoped_ptr<HttpFetcher> fetcher(this->test_.NewLargeFetcher()); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 535 | delegate.paused_ = false; |
| 536 | delegate.loop_ = loop; |
| 537 | delegate.fetcher_ = fetcher.get(); |
| 538 | fetcher->set_delegate(&delegate); |
| 539 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 540 | scoped_ptr<HttpServer> server(this->test_.CreateServer()); |
| 541 | ASSERT_TRUE(server->started_); |
Andrew de los Reyes | f3ed8e7 | 2011-02-16 10:35:46 -0800 | [diff] [blame] | 542 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 543 | guint callback_id = g_timeout_add(kHttpResponseInternalServerError, |
| 544 | UnpausingTimeoutCallback, &delegate); |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 545 | fetcher->BeginTransfer(this->test_.BigUrl(server->GetPort())); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 546 | |
| 547 | g_main_loop_run(loop); |
Andrew de los Reyes | f3ed8e7 | 2011-02-16 10:35:46 -0800 | [diff] [blame] | 548 | g_source_remove(callback_id); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 549 | } |
| 550 | g_main_loop_unref(loop); |
| 551 | } |
| 552 | |
| 553 | namespace { |
| 554 | class AbortingHttpFetcherTestDelegate : public HttpFetcherDelegate { |
| 555 | public: |
| 556 | virtual void ReceivedBytes(HttpFetcher* fetcher, |
| 557 | const char* bytes, int length) {} |
| 558 | virtual void TransferComplete(HttpFetcher* fetcher, bool successful) { |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 559 | ADD_FAILURE(); // We should never get here |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 560 | g_main_loop_quit(loop_); |
| 561 | } |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 562 | virtual void TransferTerminated(HttpFetcher* fetcher) { |
| 563 | EXPECT_EQ(fetcher, fetcher_.get()); |
| 564 | EXPECT_FALSE(once_); |
| 565 | EXPECT_TRUE(callback_once_); |
| 566 | callback_once_ = false; |
Alex Deymo | c4acdf4 | 2014-05-28 21:07:10 -0700 | [diff] [blame] | 567 | // The fetcher could have a callback scheduled on the ProxyResolver that |
| 568 | // can fire after this callback. We wait until the end of the test to |
| 569 | // delete the fetcher. |
Andrew de los Reyes | 819fef2 | 2010-12-17 11:33:58 -0800 | [diff] [blame] | 570 | } |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 571 | void TerminateTransfer() { |
| 572 | CHECK(once_); |
| 573 | once_ = false; |
| 574 | fetcher_->TerminateTransfer(); |
| 575 | } |
| 576 | void EndLoop() { |
| 577 | g_main_loop_quit(loop_); |
| 578 | } |
| 579 | bool once_; |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 580 | bool callback_once_; |
| 581 | scoped_ptr<HttpFetcher> fetcher_; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 582 | GMainLoop* loop_; |
| 583 | }; |
| 584 | |
| 585 | gboolean AbortingTimeoutCallback(gpointer data) { |
| 586 | AbortingHttpFetcherTestDelegate *delegate = |
| 587 | reinterpret_cast<AbortingHttpFetcherTestDelegate*>(data); |
| 588 | if (delegate->once_) { |
| 589 | delegate->TerminateTransfer(); |
| 590 | return TRUE; |
| 591 | } else { |
| 592 | delegate->EndLoop(); |
| 593 | return FALSE; |
| 594 | } |
| 595 | } |
Alex Vakulenko | d2779df | 2014-06-16 13:19:00 -0700 | [diff] [blame] | 596 | } // namespace |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 597 | |
| 598 | TYPED_TEST(HttpFetcherTest, AbortTest) { |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 599 | GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 600 | { |
| 601 | AbortingHttpFetcherTestDelegate delegate; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 602 | delegate.fetcher_.reset(this->test_.NewLargeFetcher()); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 603 | delegate.once_ = true; |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 604 | delegate.callback_once_ = true; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 605 | delegate.loop_ = loop; |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 606 | delegate.fetcher_->set_delegate(&delegate); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 607 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 608 | scoped_ptr<HttpServer> server(this->test_.CreateServer()); |
| 609 | this->test_.IgnoreServerAborting(server.get()); |
| 610 | ASSERT_TRUE(server->started_); |
| 611 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 612 | GSource* timeout_source_; |
| 613 | timeout_source_ = g_timeout_source_new(0); // ms |
| 614 | g_source_set_callback(timeout_source_, AbortingTimeoutCallback, &delegate, |
| 615 | NULL); |
| 616 | g_source_attach(timeout_source_, NULL); |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 617 | delegate.fetcher_->BeginTransfer(this->test_.BigUrl(server->GetPort())); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 618 | |
| 619 | g_main_loop_run(loop); |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 620 | CHECK(!delegate.once_); |
| 621 | CHECK(!delegate.callback_once_); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 622 | g_source_destroy(timeout_source_); |
| 623 | } |
| 624 | g_main_loop_unref(loop); |
| 625 | } |
| 626 | |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 627 | namespace { |
| 628 | class FlakyHttpFetcherTestDelegate : public HttpFetcherDelegate { |
| 629 | public: |
| 630 | virtual void ReceivedBytes(HttpFetcher* fetcher, |
| 631 | const char* bytes, int length) { |
| 632 | data.append(bytes, length); |
| 633 | } |
| 634 | virtual void TransferComplete(HttpFetcher* fetcher, bool successful) { |
Andrew de los Reyes | fb4ad7d | 2010-07-19 10:43:46 -0700 | [diff] [blame] | 635 | EXPECT_TRUE(successful); |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 636 | EXPECT_EQ(kHttpResponsePartialContent, fetcher->http_response_code()); |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 637 | g_main_loop_quit(loop_); |
| 638 | } |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 639 | virtual void TransferTerminated(HttpFetcher* fetcher) { |
| 640 | ADD_FAILURE(); |
| 641 | } |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 642 | string data; |
| 643 | GMainLoop* loop_; |
| 644 | }; |
Alex Vakulenko | d2779df | 2014-06-16 13:19:00 -0700 | [diff] [blame] | 645 | } // namespace |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 646 | |
| 647 | TYPED_TEST(HttpFetcherTest, FlakyTest) { |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 648 | if (this->test_.IsMock()) |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 649 | return; |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 650 | GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 651 | { |
| 652 | FlakyHttpFetcherTestDelegate delegate; |
| 653 | delegate.loop_ = loop; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 654 | scoped_ptr<HttpFetcher> fetcher(this->test_.NewSmallFetcher()); |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 655 | fetcher->set_delegate(&delegate); |
| 656 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 657 | scoped_ptr<HttpServer> server(this->test_.CreateServer()); |
| 658 | ASSERT_TRUE(server->started_); |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 659 | |
| 660 | StartTransferArgs start_xfer_args = { |
| 661 | fetcher.get(), |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 662 | LocalServerUrlForPath(server->GetPort(), |
Alex Vakulenko | 75039d7 | 2014-03-25 12:36:28 -0700 | [diff] [blame] | 663 | base::StringPrintf("/flaky/%d/%d/%d/%d", kBigLength, |
| 664 | kFlakyTruncateLength, |
| 665 | kFlakySleepEvery, |
| 666 | kFlakySleepSecs)) |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 667 | }; |
| 668 | |
| 669 | g_timeout_add(0, StartTransfer, &start_xfer_args); |
| 670 | g_main_loop_run(loop); |
| 671 | |
| 672 | // verify the data we get back |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 673 | ASSERT_EQ(kBigLength, delegate.data.size()); |
| 674 | for (int i = 0; i < kBigLength; i += 10) { |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 675 | // Assert so that we don't flood the screen w/ EXPECT errors on failure. |
| 676 | ASSERT_EQ(delegate.data.substr(i, 10), "abcdefghij"); |
| 677 | } |
| 678 | } |
| 679 | g_main_loop_unref(loop); |
| 680 | } |
| 681 | |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 682 | namespace { |
Chris Sosa | 0a364bb | 2014-06-10 18:18:24 -0700 | [diff] [blame] | 683 | // This delegate kills the server attached to it after receiving any bytes. |
| 684 | // This can be used for testing what happens when you try to fetch data and |
| 685 | // the server dies. |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 686 | class FailureHttpFetcherTestDelegate : public HttpFetcherDelegate { |
| 687 | public: |
Alex Vakulenko | d2779df | 2014-06-16 13:19:00 -0700 | [diff] [blame] | 688 | explicit FailureHttpFetcherTestDelegate(PythonHttpServer* server) |
Jay Srinivasan | 135a58b | 2012-07-13 12:46:49 -0700 | [diff] [blame] | 689 | : loop_(NULL), |
| 690 | server_(server) {} |
| 691 | |
| 692 | virtual ~FailureHttpFetcherTestDelegate() { |
| 693 | if (server_) { |
| 694 | LOG(INFO) << "Stopping server in destructor"; |
| 695 | delete server_; |
| 696 | LOG(INFO) << "server stopped"; |
| 697 | } |
| 698 | } |
| 699 | |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 700 | virtual void ReceivedBytes(HttpFetcher* fetcher, |
| 701 | const char* bytes, int length) { |
| 702 | if (server_) { |
Jay Srinivasan | 135a58b | 2012-07-13 12:46:49 -0700 | [diff] [blame] | 703 | LOG(INFO) << "Stopping server in ReceivedBytes"; |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 704 | delete server_; |
| 705 | LOG(INFO) << "server stopped"; |
| 706 | server_ = NULL; |
| 707 | } |
| 708 | } |
| 709 | virtual void TransferComplete(HttpFetcher* fetcher, bool successful) { |
| 710 | EXPECT_FALSE(successful); |
Chris Sosa | 0a364bb | 2014-06-10 18:18:24 -0700 | [diff] [blame] | 711 | EXPECT_EQ(0, fetcher->http_response_code()); |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 712 | g_main_loop_quit(loop_); |
| 713 | } |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 714 | virtual void TransferTerminated(HttpFetcher* fetcher) { |
| 715 | ADD_FAILURE(); |
| 716 | } |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 717 | GMainLoop* loop_; |
| 718 | PythonHttpServer* server_; |
| 719 | }; |
Alex Vakulenko | d2779df | 2014-06-16 13:19:00 -0700 | [diff] [blame] | 720 | } // namespace |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 721 | |
| 722 | |
| 723 | TYPED_TEST(HttpFetcherTest, FailureTest) { |
Chris Sosa | 0a364bb | 2014-06-10 18:18:24 -0700 | [diff] [blame] | 724 | // This test ensures that a fetcher responds correctly when a server isn't |
| 725 | // available at all. |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 726 | if (this->test_.IsMock()) |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 727 | return; |
| 728 | GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); |
| 729 | { |
Jay Srinivasan | 135a58b | 2012-07-13 12:46:49 -0700 | [diff] [blame] | 730 | FailureHttpFetcherTestDelegate delegate(NULL); |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 731 | delegate.loop_ = loop; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 732 | scoped_ptr<HttpFetcher> fetcher(this->test_.NewSmallFetcher()); |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 733 | fetcher->set_delegate(&delegate); |
| 734 | |
| 735 | StartTransferArgs start_xfer_args = { |
| 736 | fetcher.get(), |
Chris Sosa | 0a364bb | 2014-06-10 18:18:24 -0700 | [diff] [blame] | 737 | "http://host_doesnt_exist99999999", |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 738 | }; |
| 739 | |
| 740 | g_timeout_add(0, StartTransfer, &start_xfer_args); |
| 741 | g_main_loop_run(loop); |
| 742 | |
| 743 | // Exiting and testing happens in the delegate |
| 744 | } |
| 745 | g_main_loop_unref(loop); |
| 746 | } |
| 747 | |
| 748 | TYPED_TEST(HttpFetcherTest, ServerDiesTest) { |
Chris Sosa | 0a364bb | 2014-06-10 18:18:24 -0700 | [diff] [blame] | 749 | // This test starts a new http server and kills it after receiving its first |
| 750 | // set of bytes. It test whether or not our fetcher eventually gives up on |
| 751 | // retries and aborts correctly. |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 752 | if (this->test_.IsMock()) |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 753 | return; |
| 754 | GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); |
| 755 | { |
Chris Sosa | 0a364bb | 2014-06-10 18:18:24 -0700 | [diff] [blame] | 756 | PythonHttpServer* server = new PythonHttpServer(); |
| 757 | int port = server->GetPort(); |
| 758 | ASSERT_TRUE(server->started_); |
| 759 | |
| 760 | // Handles destruction and claims ownership. |
| 761 | FailureHttpFetcherTestDelegate delegate(server); |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 762 | delegate.loop_ = loop; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 763 | scoped_ptr<HttpFetcher> fetcher(this->test_.NewSmallFetcher()); |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 764 | fetcher->set_delegate(&delegate); |
| 765 | |
| 766 | StartTransferArgs start_xfer_args = { |
| 767 | fetcher.get(), |
Chris Sosa | 0a364bb | 2014-06-10 18:18:24 -0700 | [diff] [blame] | 768 | LocalServerUrlForPath(port, |
Alex Vakulenko | 75039d7 | 2014-03-25 12:36:28 -0700 | [diff] [blame] | 769 | base::StringPrintf("/flaky/%d/%d/%d/%d", kBigLength, |
| 770 | kFlakyTruncateLength, |
| 771 | kFlakySleepEvery, |
| 772 | kFlakySleepSecs)) |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 773 | }; |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 774 | g_timeout_add(0, StartTransfer, &start_xfer_args); |
| 775 | g_main_loop_run(loop); |
| 776 | |
| 777 | // Exiting and testing happens in the delegate |
| 778 | } |
| 779 | g_main_loop_unref(loop); |
| 780 | } |
| 781 | |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 782 | namespace { |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 783 | const HttpResponseCode kRedirectCodes[] = { |
| 784 | kHttpResponseMovedPermanently, kHttpResponseFound, kHttpResponseSeeOther, |
| 785 | kHttpResponseTempRedirect |
| 786 | }; |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 787 | |
| 788 | class RedirectHttpFetcherTestDelegate : public HttpFetcherDelegate { |
| 789 | public: |
Alex Vakulenko | d2779df | 2014-06-16 13:19:00 -0700 | [diff] [blame] | 790 | explicit RedirectHttpFetcherTestDelegate(bool expected_successful) |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 791 | : expected_successful_(expected_successful) {} |
| 792 | virtual void ReceivedBytes(HttpFetcher* fetcher, |
| 793 | const char* bytes, int length) { |
| 794 | data.append(bytes, length); |
| 795 | } |
| 796 | virtual void TransferComplete(HttpFetcher* fetcher, bool successful) { |
| 797 | EXPECT_EQ(expected_successful_, successful); |
Alex Vakulenko | d2779df | 2014-06-16 13:19:00 -0700 | [diff] [blame] | 798 | if (expected_successful_) { |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 799 | EXPECT_EQ(kHttpResponseOk, fetcher->http_response_code()); |
Alex Vakulenko | d2779df | 2014-06-16 13:19:00 -0700 | [diff] [blame] | 800 | } else { |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 801 | EXPECT_GE(fetcher->http_response_code(), kHttpResponseMovedPermanently); |
| 802 | EXPECT_LE(fetcher->http_response_code(), kHttpResponseTempRedirect); |
Darin Petkov | cb46621 | 2010-08-26 09:40:11 -0700 | [diff] [blame] | 803 | } |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 804 | g_main_loop_quit(loop_); |
| 805 | } |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 806 | virtual void TransferTerminated(HttpFetcher* fetcher) { |
| 807 | ADD_FAILURE(); |
| 808 | } |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 809 | bool expected_successful_; |
| 810 | string data; |
| 811 | GMainLoop* loop_; |
| 812 | }; |
| 813 | |
| 814 | // RedirectTest takes ownership of |http_fetcher|. |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 815 | void RedirectTest(const HttpServer* server, |
| 816 | bool expected_successful, |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 817 | const string& url, |
| 818 | HttpFetcher* http_fetcher) { |
| 819 | GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); |
Jay Srinivasan | 135a58b | 2012-07-13 12:46:49 -0700 | [diff] [blame] | 820 | { |
| 821 | RedirectHttpFetcherTestDelegate delegate(expected_successful); |
| 822 | delegate.loop_ = loop; |
| 823 | scoped_ptr<HttpFetcher> fetcher(http_fetcher); |
| 824 | fetcher->set_delegate(&delegate); |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 825 | |
Jay Srinivasan | 135a58b | 2012-07-13 12:46:49 -0700 | [diff] [blame] | 826 | StartTransferArgs start_xfer_args = |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 827 | { fetcher.get(), LocalServerUrlForPath(server->GetPort(), url) }; |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 828 | |
Jay Srinivasan | 135a58b | 2012-07-13 12:46:49 -0700 | [diff] [blame] | 829 | g_timeout_add(0, StartTransfer, &start_xfer_args); |
| 830 | g_main_loop_run(loop); |
| 831 | if (expected_successful) { |
| 832 | // verify the data we get back |
| 833 | ASSERT_EQ(kMediumLength, delegate.data.size()); |
| 834 | for (int i = 0; i < kMediumLength; i += 10) { |
| 835 | // Assert so that we don't flood the screen w/ EXPECT errors on failure. |
| 836 | ASSERT_EQ(delegate.data.substr(i, 10), "abcdefghij"); |
| 837 | } |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 838 | } |
| 839 | } |
| 840 | g_main_loop_unref(loop); |
| 841 | } |
Alex Vakulenko | d2779df | 2014-06-16 13:19:00 -0700 | [diff] [blame] | 842 | } // namespace |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 843 | |
| 844 | TYPED_TEST(HttpFetcherTest, SimpleRedirectTest) { |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 845 | if (this->test_.IsMock()) |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 846 | return; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 847 | |
| 848 | scoped_ptr<HttpServer> server(this->test_.CreateServer()); |
| 849 | ASSERT_TRUE(server->started_); |
| 850 | |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 851 | for (size_t c = 0; c < arraysize(kRedirectCodes); ++c) { |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 852 | const string url = base::StringPrintf("/redirect/%d/download/%d", |
| 853 | kRedirectCodes[c], |
| 854 | kMediumLength); |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 855 | RedirectTest(server.get(), true, url, this->test_.NewLargeFetcher()); |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 856 | } |
| 857 | } |
| 858 | |
| 859 | TYPED_TEST(HttpFetcherTest, MaxRedirectTest) { |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 860 | if (this->test_.IsMock()) |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 861 | return; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 862 | |
| 863 | scoped_ptr<HttpServer> server(this->test_.CreateServer()); |
| 864 | ASSERT_TRUE(server->started_); |
| 865 | |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 866 | string url; |
David Zeuthen | 34135a9 | 2013-08-06 11:16:16 -0700 | [diff] [blame] | 867 | for (int r = 0; r < kDownloadMaxRedirects; r++) { |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 868 | url += base::StringPrintf("/redirect/%d", |
| 869 | kRedirectCodes[r % arraysize(kRedirectCodes)]); |
| 870 | } |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 871 | url += base::StringPrintf("/download/%d", kMediumLength); |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 872 | RedirectTest(server.get(), true, url, this->test_.NewLargeFetcher()); |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 873 | } |
| 874 | |
| 875 | TYPED_TEST(HttpFetcherTest, BeyondMaxRedirectTest) { |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 876 | if (this->test_.IsMock()) |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 877 | return; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 878 | |
| 879 | scoped_ptr<HttpServer> server(this->test_.CreateServer()); |
| 880 | ASSERT_TRUE(server->started_); |
| 881 | |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 882 | string url; |
David Zeuthen | 34135a9 | 2013-08-06 11:16:16 -0700 | [diff] [blame] | 883 | for (int r = 0; r < kDownloadMaxRedirects + 1; r++) { |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 884 | url += base::StringPrintf("/redirect/%d", |
| 885 | kRedirectCodes[r % arraysize(kRedirectCodes)]); |
| 886 | } |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 887 | url += base::StringPrintf("/download/%d", kMediumLength); |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 888 | RedirectTest(server.get(), false, url, this->test_.NewLargeFetcher()); |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 889 | } |
| 890 | |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 891 | namespace { |
| 892 | class MultiHttpFetcherTestDelegate : public HttpFetcherDelegate { |
| 893 | public: |
Alex Vakulenko | d2779df | 2014-06-16 13:19:00 -0700 | [diff] [blame] | 894 | explicit MultiHttpFetcherTestDelegate(int expected_response_code) |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 895 | : expected_response_code_(expected_response_code) {} |
Gilad Arnold | e4ad250 | 2011-12-29 17:08:54 -0800 | [diff] [blame] | 896 | |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 897 | virtual void ReceivedBytes(HttpFetcher* fetcher, |
| 898 | const char* bytes, int length) { |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 899 | EXPECT_EQ(fetcher, fetcher_.get()); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 900 | data.append(bytes, length); |
| 901 | } |
Gilad Arnold | e4ad250 | 2011-12-29 17:08:54 -0800 | [diff] [blame] | 902 | |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 903 | virtual void TransferComplete(HttpFetcher* fetcher, bool successful) { |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 904 | EXPECT_EQ(fetcher, fetcher_.get()); |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 905 | EXPECT_EQ(expected_response_code_ != kHttpResponseUndefined, successful); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 906 | if (expected_response_code_ != 0) |
| 907 | EXPECT_EQ(expected_response_code_, fetcher->http_response_code()); |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 908 | // Destroy the fetcher (because we're allowed to). |
| 909 | fetcher_.reset(NULL); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 910 | g_main_loop_quit(loop_); |
| 911 | } |
Gilad Arnold | e4ad250 | 2011-12-29 17:08:54 -0800 | [diff] [blame] | 912 | |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 913 | virtual void TransferTerminated(HttpFetcher* fetcher) { |
| 914 | ADD_FAILURE(); |
| 915 | } |
Gilad Arnold | e4ad250 | 2011-12-29 17:08:54 -0800 | [diff] [blame] | 916 | |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 917 | scoped_ptr<HttpFetcher> fetcher_; |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 918 | int expected_response_code_; |
| 919 | string data; |
| 920 | GMainLoop* loop_; |
| 921 | }; |
| 922 | |
| 923 | void MultiTest(HttpFetcher* fetcher_in, |
| 924 | const string& url, |
Andrew de los Reyes | 819fef2 | 2010-12-17 11:33:58 -0800 | [diff] [blame] | 925 | const vector<pair<off_t, off_t> >& ranges, |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 926 | const string& expected_prefix, |
| 927 | off_t expected_size, |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 928 | HttpResponseCode expected_response_code) { |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 929 | GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); |
| 930 | { |
| 931 | MultiHttpFetcherTestDelegate delegate(expected_response_code); |
| 932 | delegate.loop_ = loop; |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 933 | delegate.fetcher_.reset(fetcher_in); |
Jay Srinivasan | 4348879 | 2012-06-19 00:25:31 -0700 | [diff] [blame] | 934 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 935 | MultiRangeHttpFetcher* multi_fetcher = |
| 936 | dynamic_cast<MultiRangeHttpFetcher*>(fetcher_in); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 937 | ASSERT_TRUE(multi_fetcher); |
Andrew de los Reyes | 819fef2 | 2010-12-17 11:33:58 -0800 | [diff] [blame] | 938 | multi_fetcher->ClearRanges(); |
| 939 | for (vector<pair<off_t, off_t> >::const_iterator it = ranges.begin(), |
| 940 | e = ranges.end(); it != e; ++it) { |
Alex Vakulenko | 75039d7 | 2014-03-25 12:36:28 -0700 | [diff] [blame] | 941 | std::string tmp_str = base::StringPrintf("%jd+", it->first); |
Gilad Arnold | e4ad250 | 2011-12-29 17:08:54 -0800 | [diff] [blame] | 942 | if (it->second > 0) { |
| 943 | base::StringAppendF(&tmp_str, "%jd", it->second); |
| 944 | multi_fetcher->AddRange(it->first, it->second); |
| 945 | } else { |
| 946 | base::StringAppendF(&tmp_str, "?"); |
| 947 | multi_fetcher->AddRange(it->first); |
| 948 | } |
| 949 | LOG(INFO) << "added range: " << tmp_str; |
Andrew de los Reyes | 819fef2 | 2010-12-17 11:33:58 -0800 | [diff] [blame] | 950 | } |
Gilad Arnold | 5bb4c90 | 2014-04-10 12:32:13 -0700 | [diff] [blame] | 951 | dynamic_cast<FakeSystemState*>(fetcher_in->GetSystemState()) |
Gilad Arnold | 1f84723 | 2014-04-07 12:07:49 -0700 | [diff] [blame] | 952 | ->fake_hardware()->SetIsOfficialBuild(false); |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 953 | multi_fetcher->set_delegate(&delegate); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 954 | |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 955 | StartTransferArgs start_xfer_args = {multi_fetcher, url}; |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 956 | |
| 957 | g_timeout_add(0, StartTransfer, &start_xfer_args); |
| 958 | g_main_loop_run(loop); |
| 959 | |
| 960 | EXPECT_EQ(expected_size, delegate.data.size()); |
| 961 | EXPECT_EQ(expected_prefix, |
| 962 | string(delegate.data.data(), expected_prefix.size())); |
| 963 | } |
| 964 | g_main_loop_unref(loop); |
| 965 | } |
Alex Vakulenko | d2779df | 2014-06-16 13:19:00 -0700 | [diff] [blame] | 966 | } // namespace |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 967 | |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 968 | TYPED_TEST(HttpFetcherTest, MultiHttpFetcherSimpleTest) { |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 969 | if (!this->test_.IsMulti()) |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 970 | return; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 971 | |
| 972 | scoped_ptr<HttpServer> server(this->test_.CreateServer()); |
| 973 | ASSERT_TRUE(server->started_); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 974 | |
Andrew de los Reyes | 819fef2 | 2010-12-17 11:33:58 -0800 | [diff] [blame] | 975 | vector<pair<off_t, off_t> > ranges; |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 976 | ranges.push_back(make_pair(0, 25)); |
Gilad Arnold | e4ad250 | 2011-12-29 17:08:54 -0800 | [diff] [blame] | 977 | ranges.push_back(make_pair(99, 0)); |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 978 | MultiTest(this->test_.NewLargeFetcher(), |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 979 | this->test_.BigUrl(server->GetPort()), |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 980 | ranges, |
| 981 | "abcdefghijabcdefghijabcdejabcdefghijabcdef", |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 982 | kBigLength - (99 - 25), |
| 983 | kHttpResponsePartialContent); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 984 | } |
| 985 | |
| 986 | TYPED_TEST(HttpFetcherTest, MultiHttpFetcherLengthLimitTest) { |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 987 | if (!this->test_.IsMulti()) |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 988 | return; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 989 | |
| 990 | scoped_ptr<HttpServer> server(this->test_.CreateServer()); |
| 991 | ASSERT_TRUE(server->started_); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 992 | |
Andrew de los Reyes | 819fef2 | 2010-12-17 11:33:58 -0800 | [diff] [blame] | 993 | vector<pair<off_t, off_t> > ranges; |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 994 | ranges.push_back(make_pair(0, 24)); |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 995 | MultiTest(this->test_.NewLargeFetcher(), |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 996 | this->test_.BigUrl(server->GetPort()), |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 997 | ranges, |
| 998 | "abcdefghijabcdefghijabcd", |
| 999 | 24, |
Gilad Arnold | e4ad250 | 2011-12-29 17:08:54 -0800 | [diff] [blame] | 1000 | kHttpResponsePartialContent); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 1001 | } |
| 1002 | |
| 1003 | TYPED_TEST(HttpFetcherTest, MultiHttpFetcherMultiEndTest) { |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 1004 | if (!this->test_.IsMulti()) |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 1005 | return; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 1006 | |
| 1007 | scoped_ptr<HttpServer> server(this->test_.CreateServer()); |
| 1008 | ASSERT_TRUE(server->started_); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 1009 | |
Andrew de los Reyes | 819fef2 | 2010-12-17 11:33:58 -0800 | [diff] [blame] | 1010 | vector<pair<off_t, off_t> > ranges; |
Gilad Arnold | e4ad250 | 2011-12-29 17:08:54 -0800 | [diff] [blame] | 1011 | ranges.push_back(make_pair(kBigLength - 2, 0)); |
| 1012 | ranges.push_back(make_pair(kBigLength - 3, 0)); |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 1013 | MultiTest(this->test_.NewLargeFetcher(), |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 1014 | this->test_.BigUrl(server->GetPort()), |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 1015 | ranges, |
| 1016 | "ijhij", |
| 1017 | 5, |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 1018 | kHttpResponsePartialContent); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 1019 | } |
| 1020 | |
| 1021 | TYPED_TEST(HttpFetcherTest, MultiHttpFetcherInsufficientTest) { |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 1022 | if (!this->test_.IsMulti()) |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 1023 | return; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 1024 | |
| 1025 | scoped_ptr<HttpServer> server(this->test_.CreateServer()); |
| 1026 | ASSERT_TRUE(server->started_); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 1027 | |
Andrew de los Reyes | 819fef2 | 2010-12-17 11:33:58 -0800 | [diff] [blame] | 1028 | vector<pair<off_t, off_t> > ranges; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 1029 | ranges.push_back(make_pair(kBigLength - 2, 4)); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 1030 | for (int i = 0; i < 2; ++i) { |
Andrew de los Reyes | 819fef2 | 2010-12-17 11:33:58 -0800 | [diff] [blame] | 1031 | LOG(INFO) << "i = " << i; |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 1032 | MultiTest(this->test_.NewLargeFetcher(), |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 1033 | this->test_.BigUrl(server->GetPort()), |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 1034 | ranges, |
| 1035 | "ij", |
| 1036 | 2, |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 1037 | kHttpResponseUndefined); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 1038 | ranges.push_back(make_pair(0, 5)); |
| 1039 | } |
| 1040 | } |
| 1041 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 1042 | // Issue #18143: when a fetch of a secondary chunk out of a chain, then it |
| 1043 | // should retry with other proxies listed before giving up. |
| 1044 | // |
| 1045 | // (1) successful recovery: The offset fetch will fail twice but succeed with |
| 1046 | // the third proxy. |
| 1047 | TYPED_TEST(HttpFetcherTest, MultiHttpFetcherErrorIfOffsetRecoverableTest) { |
| 1048 | if (!this->test_.IsMulti()) |
| 1049 | return; |
| 1050 | |
| 1051 | scoped_ptr<HttpServer> server(this->test_.CreateServer()); |
| 1052 | ASSERT_TRUE(server->started_); |
| 1053 | |
| 1054 | vector<pair<off_t, off_t> > ranges; |
| 1055 | ranges.push_back(make_pair(0, 25)); |
Gilad Arnold | e4ad250 | 2011-12-29 17:08:54 -0800 | [diff] [blame] | 1056 | ranges.push_back(make_pair(99, 0)); |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 1057 | MultiTest(this->test_.NewLargeFetcher(3), |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 1058 | LocalServerUrlForPath(server->GetPort(), |
| 1059 | base::StringPrintf("/error-if-offset/%d/2", |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 1060 | kBigLength)), |
| 1061 | ranges, |
| 1062 | "abcdefghijabcdefghijabcdejabcdefghijabcdef", |
| 1063 | kBigLength - (99 - 25), |
| 1064 | kHttpResponsePartialContent); |
| 1065 | } |
| 1066 | |
| 1067 | // (2) unsuccessful recovery: The offset fetch will fail repeatedly. The |
| 1068 | // fetcher will signal a (failed) completed transfer to the delegate. |
| 1069 | TYPED_TEST(HttpFetcherTest, MultiHttpFetcherErrorIfOffsetUnrecoverableTest) { |
| 1070 | if (!this->test_.IsMulti()) |
| 1071 | return; |
| 1072 | |
| 1073 | scoped_ptr<HttpServer> server(this->test_.CreateServer()); |
| 1074 | ASSERT_TRUE(server->started_); |
| 1075 | |
| 1076 | vector<pair<off_t, off_t> > ranges; |
| 1077 | ranges.push_back(make_pair(0, 25)); |
Gilad Arnold | e4ad250 | 2011-12-29 17:08:54 -0800 | [diff] [blame] | 1078 | ranges.push_back(make_pair(99, 0)); |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 1079 | MultiTest(this->test_.NewLargeFetcher(2), |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 1080 | LocalServerUrlForPath(server->GetPort(), |
| 1081 | base::StringPrintf("/error-if-offset/%d/3", |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 1082 | kBigLength)), |
| 1083 | ranges, |
| 1084 | "abcdefghijabcdefghijabcde", // only received the first chunk |
| 1085 | 25, |
| 1086 | kHttpResponseUndefined); |
| 1087 | } |
| 1088 | |
| 1089 | |
| 1090 | |
Andrew de los Reyes | d57d147 | 2010-10-21 13:34:08 -0700 | [diff] [blame] | 1091 | namespace { |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 1092 | class BlockedTransferTestDelegate : public HttpFetcherDelegate { |
Andrew de los Reyes | d57d147 | 2010-10-21 13:34:08 -0700 | [diff] [blame] | 1093 | public: |
| 1094 | virtual void ReceivedBytes(HttpFetcher* fetcher, |
| 1095 | const char* bytes, int length) { |
| 1096 | ADD_FAILURE(); |
| 1097 | } |
| 1098 | virtual void TransferComplete(HttpFetcher* fetcher, bool successful) { |
| 1099 | EXPECT_FALSE(successful); |
| 1100 | g_main_loop_quit(loop_); |
| 1101 | } |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 1102 | virtual void TransferTerminated(HttpFetcher* fetcher) { |
| 1103 | ADD_FAILURE(); |
| 1104 | } |
Andrew de los Reyes | d57d147 | 2010-10-21 13:34:08 -0700 | [diff] [blame] | 1105 | GMainLoop* loop_; |
| 1106 | }; |
| 1107 | |
| 1108 | } // namespace |
| 1109 | |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 1110 | TYPED_TEST(HttpFetcherTest, BlockedTransferTest) { |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 1111 | if (this->test_.IsMock() || this->test_.IsMulti()) |
Andrew de los Reyes | d57d147 | 2010-10-21 13:34:08 -0700 | [diff] [blame] | 1112 | return; |
Andrew de los Reyes | d57d147 | 2010-10-21 13:34:08 -0700 | [diff] [blame] | 1113 | |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 1114 | for (int i = 0; i < 2; i++) { |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 1115 | scoped_ptr<HttpServer> server(this->test_.CreateServer()); |
| 1116 | ASSERT_TRUE(server->started_); |
Andrew de los Reyes | d57d147 | 2010-10-21 13:34:08 -0700 | [diff] [blame] | 1117 | |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 1118 | GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); |
Jay Srinivasan | 135a58b | 2012-07-13 12:46:49 -0700 | [diff] [blame] | 1119 | { |
| 1120 | BlockedTransferTestDelegate delegate; |
| 1121 | delegate.loop_ = loop; |
Andrew de los Reyes | d57d147 | 2010-10-21 13:34:08 -0700 | [diff] [blame] | 1122 | |
Jay Srinivasan | 135a58b | 2012-07-13 12:46:49 -0700 | [diff] [blame] | 1123 | bool is_allowed = (i != 0); |
| 1124 | scoped_ptr<HttpFetcher> fetcher(this->test_.NewLargeFetcher()); |
Jay Srinivasan | 4348879 | 2012-06-19 00:25:31 -0700 | [diff] [blame] | 1125 | |
Jay Srinivasan | 135a58b | 2012-07-13 12:46:49 -0700 | [diff] [blame] | 1126 | bool is_official_build = (i == 1); |
| 1127 | LOG(INFO) << "is_update_allowed_over_connection: " << is_allowed; |
| 1128 | LOG(INFO) << "is_official_build: " << is_official_build; |
Gilad Arnold | 5bb4c90 | 2014-04-10 12:32:13 -0700 | [diff] [blame] | 1129 | // NewLargeFetcher creates the HttpFetcher* with a FakeSystemState. |
| 1130 | dynamic_cast<FakeSystemState*>(fetcher->GetSystemState()) |
Gilad Arnold | 1f84723 | 2014-04-07 12:07:49 -0700 | [diff] [blame] | 1131 | ->fake_hardware()->SetIsOfficialBuild(is_official_build); |
Jay Srinivasan | 135a58b | 2012-07-13 12:46:49 -0700 | [diff] [blame] | 1132 | fetcher->set_delegate(&delegate); |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 1133 | |
Jay Srinivasan | 135a58b | 2012-07-13 12:46:49 -0700 | [diff] [blame] | 1134 | StartTransferArgs start_xfer_args = |
Gilad Arnold | b6c562a | 2013-07-01 02:19:26 -0700 | [diff] [blame] | 1135 | {fetcher.get(), |
| 1136 | LocalServerUrlForPath(server->GetPort(), |
| 1137 | this->test_.SmallUrl(server->GetPort()))}; |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 1138 | |
Jay Srinivasan | 135a58b | 2012-07-13 12:46:49 -0700 | [diff] [blame] | 1139 | g_timeout_add(0, StartTransfer, &start_xfer_args); |
| 1140 | g_main_loop_run(loop); |
| 1141 | } |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 1142 | g_main_loop_unref(loop); |
| 1143 | } |
Andrew de los Reyes | d57d147 | 2010-10-21 13:34:08 -0700 | [diff] [blame] | 1144 | } |
| 1145 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 1146 | } // namespace chromeos_update_engine |