1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "base/basictypes.h"
6 #include "base/compiler_specific.h"
7 #include "base/memory/scoped_ptr.h"
8 #include "base/stl_util.h"
9 #include "base/strings/string_number_conversions.h"
10 #include "net/base/test_completion_callback.h"
11 #include "net/base/upload_bytes_element_reader.h"
12 #include "net/base/upload_data_stream.h"
13 #include "net/cert/mock_cert_verifier.h"
14 #include "net/dns/mapped_host_resolver.h"
15 #include "net/dns/mock_host_resolver.h"
16 #include "net/http/http_auth_handler_factory.h"
17 #include "net/http/http_network_session.h"
18 #include "net/http/http_network_transaction.h"
19 #include "net/http/http_server_properties_impl.h"
20 #include "net/http/http_transaction_unittest.h"
21 #include "net/http/transport_security_state.h"
22 #include "net/proxy/proxy_service.h"
23 #include "net/quic/test_tools/quic_test_utils.h"
24 #include "net/ssl/ssl_config_service_defaults.h"
25 #include "net/tools/quic/quic_in_memory_cache.h"
26 #include "net/tools/quic/test_tools/quic_in_memory_cache_peer.h"
27 #include "net/tools/quic/test_tools/server_thread.h"
28 #include "testing/gtest/include/gtest/gtest.h"
29 #include "testing/platform_test.h"
31 using base::StringPiece;
32 using net::tools::QuicInMemoryCache;
33 using net::tools::test::QuicInMemoryCachePeer;
34 using net::tools::test::ServerThread;
41 const char kResponseBody[] = "some arbitrary response body";
43 // Factory for creating HttpTransactions, used by TestTransactionConsumer.
44 class TestTransactionFactory : public HttpTransactionFactory {
46 TestTransactionFactory(const HttpNetworkSession::Params& params)
47 : session_(new HttpNetworkSession(params)) {}
49 virtual ~TestTransactionFactory() {
52 // HttpTransactionFactory methods
53 virtual int CreateTransaction(RequestPriority priority,
54 scoped_ptr<HttpTransaction>* trans) OVERRIDE {
55 trans->reset(new HttpNetworkTransaction(priority, session_));
59 virtual HttpCache* GetCache() OVERRIDE {
63 virtual HttpNetworkSession* GetSession() OVERRIDE {
68 scoped_refptr<HttpNetworkSession> session_;
73 class QuicEndToEndTest : public PlatformTest {
76 : host_resolver_impl_(CreateResolverImpl()),
77 host_resolver_(host_resolver_impl_.PassAs<HostResolver>()),
78 ssl_config_service_(new SSLConfigServiceDefaults),
79 proxy_service_(ProxyService::CreateDirect()),
80 auth_handler_factory_(
81 HttpAuthHandlerFactory::CreateDefault(&host_resolver_)),
82 strike_register_no_startup_period_(false) {
83 request_.method = "GET";
84 request_.url = GURL("http://www.google.com/");
85 request_.load_flags = 0;
87 params_.enable_quic = true;
88 params_.quic_clock = NULL;
89 params_.quic_random = NULL;
90 params_.host_resolver = &host_resolver_;
91 params_.cert_verifier = &cert_verifier_;
92 params_.transport_security_state = &transport_security_state_;
93 params_.proxy_service = proxy_service_.get();
94 params_.ssl_config_service = ssl_config_service_.get();
95 params_.http_auth_handler_factory = auth_handler_factory_.get();
96 params_.http_server_properties = http_server_properties.GetWeakPtr();
99 // Creates a mock host resolver in which www.google.com
100 // resolves to localhost.
101 static MockHostResolver* CreateResolverImpl() {
102 MockHostResolver* resolver = new MockHostResolver();
103 resolver->rules()->AddRule("www.google.com", "127.0.0.1");
107 virtual void SetUp() {
108 QuicInMemoryCachePeer::ResetForTests();
111 // Use a mapped host resolver so that request for www.google.com (port 80)
112 // reach the server running on localhost.
113 std::string map_rule = "MAP www.google.com www.google.com:" +
114 base::IntToString(server_thread_->GetPort());
115 EXPECT_TRUE(host_resolver_.AddRuleFromString(map_rule));
117 // To simplify the test, and avoid the race with the HTTP request, we force
118 // QUIC for these requests.
119 params_.origin_to_force_quic_on =
120 HostPortPair::FromString("www.google.com:80");
122 transaction_factory_.reset(new TestTransactionFactory(params_));
125 virtual void TearDown() {
127 QuicInMemoryCachePeer::ResetForTests();
130 // Starts the QUIC server listening on a random port.
132 net::IPAddressNumber ip;
133 CHECK(net::ParseIPLiteralToNumber("127.0.0.1", &ip));
134 server_address_ = IPEndPoint(ip, 0);
135 server_config_.SetDefaults();
136 server_thread_.reset(new ServerThread(server_address_, server_config_,
137 QuicSupportedVersions(),
138 strike_register_no_startup_period_,
139 kInitialFlowControlWindowForTest));
140 server_thread_->Initialize();
141 server_address_ = IPEndPoint(server_address_.address(),
142 server_thread_->GetPort());
143 server_thread_->Start();
144 server_started_ = true;
147 // Stops the QUIC server.
149 if (!server_started_) {
152 if (server_thread_.get()) {
153 server_thread_->Quit();
154 server_thread_->Join();
158 // Adds an entry to the cache used by the QUIC server to serve
160 void AddToCache(const StringPiece& method,
161 const StringPiece& path,
162 const StringPiece& version,
163 const StringPiece& response_code,
164 const StringPiece& response_detail,
165 const StringPiece& body) {
166 QuicInMemoryCache::GetInstance()->AddSimpleResponse(
167 method, path, version, response_code, response_detail, body);
170 // Populates |request_body_| with |length_| ASCII bytes.
171 void GenerateBody(size_t length) {
172 request_body_.clear();
173 request_body_.reserve(length);
174 for (size_t i = 0; i < length; ++i) {
175 request_body_.append(1, static_cast<char>(32 + i % (126 - 32)));
179 // Initializes |request_| for a post of |length| bytes.
180 void InitializePostRequest(size_t length) {
181 GenerateBody(length);
182 ScopedVector<UploadElementReader> element_readers;
183 element_readers.push_back(
184 new UploadBytesElementReader(request_body_.data(),
185 request_body_.length()));
186 upload_data_stream_.reset(new UploadDataStream(element_readers.Pass(), 0));
187 request_.method = "POST";
188 request_.url = GURL("http://www.google.com/");
189 request_.upload_data_stream = upload_data_stream_.get();
190 ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback()));
193 // Checks that |consumer| completed and received |status_line| and |body|.
194 void CheckResponse(const TestTransactionConsumer& consumer,
195 const std::string& status_line,
196 const std::string& body) {
197 ASSERT_TRUE(consumer.is_done());
198 EXPECT_EQ(OK, consumer.error());
199 EXPECT_EQ(status_line,
200 consumer.response_info()->headers->GetStatusLine());
201 EXPECT_EQ(body, consumer.content());
204 scoped_ptr<MockHostResolver> host_resolver_impl_;
205 MappedHostResolver host_resolver_;
206 MockCertVerifier cert_verifier_;
207 TransportSecurityState transport_security_state_;
208 scoped_refptr<SSLConfigServiceDefaults> ssl_config_service_;
209 scoped_ptr<ProxyService> proxy_service_;
210 scoped_ptr<HttpAuthHandlerFactory> auth_handler_factory_;
211 HttpServerPropertiesImpl http_server_properties;
212 HttpNetworkSession::Params params_;
213 scoped_ptr<TestTransactionFactory> transaction_factory_;
214 HttpRequestInfo request_;
215 std::string request_body_;
216 scoped_ptr<UploadDataStream> upload_data_stream_;
217 scoped_ptr<ServerThread> server_thread_;
218 IPEndPoint server_address_;
219 std::string server_hostname_;
220 QuicConfig server_config_;
221 bool server_started_;
222 bool strike_register_no_startup_period_;
225 TEST_F(QuicEndToEndTest, LargeGetWithNoPacketLoss) {
226 std::string response(10 * 1024, 'x');
228 AddToCache("GET", request_.url.spec(),
229 "HTTP/1.1", "200", "OK",
232 TestTransactionConsumer consumer(DEFAULT_PRIORITY,
233 transaction_factory_.get());
234 consumer.Start(&request_, BoundNetLog());
236 // Will terminate when the last consumer completes.
237 base::MessageLoop::current()->Run();
239 CheckResponse(consumer, "HTTP/1.1 200 OK", response);
242 // http://crbug.com/307284
243 TEST_F(QuicEndToEndTest, DISABLED_LargePostWithNoPacketLoss) {
244 InitializePostRequest(10 * 1024 * 1024);
246 AddToCache("POST", request_.url.spec(),
247 "HTTP/1.1", "200", "OK",
250 TestTransactionConsumer consumer(DEFAULT_PRIORITY,
251 transaction_factory_.get());
252 consumer.Start(&request_, BoundNetLog());
254 // Will terminate when the last consumer completes.
255 base::MessageLoop::current()->Run();
257 CheckResponse(consumer, "HTTP/1.1 200 OK", kResponseBody);
260 TEST_F(QuicEndToEndTest, LargePostWithPacketLoss) {
261 // FLAGS_fake_packet_loss_percentage = 30;
262 InitializePostRequest(1024 * 1024);
264 const char kResponseBody[] = "some really big response body";
265 AddToCache("POST", request_.url.spec(),
266 "HTTP/1.1", "200", "OK",
269 TestTransactionConsumer consumer(DEFAULT_PRIORITY,
270 transaction_factory_.get());
271 consumer.Start(&request_, BoundNetLog());
273 // Will terminate when the last consumer completes.
274 base::MessageLoop::current()->Run();
276 CheckResponse(consumer, "HTTP/1.1 200 OK", kResponseBody);
279 TEST_F(QuicEndToEndTest, UberTest) {
280 // FLAGS_fake_packet_loss_percentage = 30;
282 const char kResponseBody[] = "some really big response body";
283 AddToCache("GET", request_.url.spec(),
284 "HTTP/1.1", "200", "OK",
287 std::vector<TestTransactionConsumer*> consumers;
288 size_t num_requests = 100;
289 for (size_t i = 0; i < num_requests; ++i) {
290 TestTransactionConsumer* consumer =
291 new TestTransactionConsumer(DEFAULT_PRIORITY,
292 transaction_factory_.get());
293 consumers.push_back(consumer);
294 consumer->Start(&request_, BoundNetLog());
297 // Will terminate when the last consumer completes.
298 base::MessageLoop::current()->Run();
300 for (size_t i = 0; i < num_requests; ++i) {
301 CheckResponse(*consumers[i], "HTTP/1.1 200 OK", kResponseBody);
303 STLDeleteElements(&consumers);